2 //===-------------------------- optional ----------------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 #ifndef _LIBCPP_OPTIONAL
12 #define _LIBCPP_OPTIONAL
20 // 23.6.3, optional for object types
21 template <class T> class optional;
23 // 23.6.4, no-value state indicator
24 struct nullopt_t{see below };
25 constexpr nullopt_t nullopt(unspecified );
27 // 23.6.5, class bad_optional_access
28 class bad_optional_access;
30 // 23.6.6, relational operators
31 template <class T, class U>
32 constexpr bool operator==(const optional<T>&, const optional<U>&);
33 template <class T, class U>
34 constexpr bool operator!=(const optional<T>&, const optional<U>&);
35 template <class T, class U>
36 constexpr bool operator<(const optional<T>&, const optional<U>&);
37 template <class T, class U>
38 constexpr bool operator>(const optional<T>&, const optional<U>&);
39 template <class T, class U>
40 constexpr bool operator<=(const optional<T>&, const optional<U>&);
41 template <class T, class U>
42 constexpr bool operator>=(const optional<T>&, const optional<U>&);
44 // 23.6.7 comparison with nullopt
45 template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
46 template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
47 template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
48 template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
49 template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
50 template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
51 template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
52 template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
53 template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
54 template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
55 template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
56 template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;
58 // 23.6.8, comparison with T
59 template <class T, class U> constexpr bool operator==(const optional<T>&, const U&);
60 template <class T, class U> constexpr bool operator==(const U&, const optional<T>&);
61 template <class T, class U> constexpr bool operator!=(const optional<T>&, const U&);
62 template <class T, class U> constexpr bool operator!=(const U&, const optional<T>&);
63 template <class T, class U> constexpr bool operator<(const optional<T>&, const U&);
64 template <class T, class U> constexpr bool operator<(const U&, const optional<T>&);
65 template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
66 template <class T, class U> constexpr bool operator<=(const U&, const optional<T>&);
67 template <class T, class U> constexpr bool operator>(const optional<T>&, const U&);
68 template <class T, class U> constexpr bool operator>(const U&, const optional<T>&);
69 template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
70 template <class T, class U> constexpr bool operator>=(const U&, const optional<T>&);
72 // 23.6.9, specialized algorithms
73 template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below );
74 template <class T> constexpr optional<see below > make_optional(T&&);
75 template <class T, class... Args>
76 constexpr optional<T> make_optional(Args&&... args);
77 template <class T, class U, class... Args>
78 constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
80 // 23.6.10, hash support
81 template <class T> struct hash;
82 template <class T> struct hash<optional<T>>;
84 template <class T> class optional {
88 // 23.6.3.1, constructors
89 constexpr optional() noexcept;
90 constexpr optional(nullopt_t) noexcept;
91 optional(const optional &);
92 optional(optional &&) noexcept(see below);
93 template <class... Args> constexpr explicit optional(in_place_t, Args &&...);
94 template <class U, class... Args>
95 constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...);
96 template <class U = T>
97 constexpr EXPLICIT optional(U &&);
99 constexpr EXPLICIT optional(const optional<U> &);
101 constexpr EXPLICIT optional(optional<U> &&);
103 // 23.6.3.2, destructor
106 // 23.6.3.3, assignment
107 optional &operator=(nullopt_t) noexcept;
108 optional &operator=(const optional &);
109 optional &operator=(optional &&) noexcept(see below );
110 template <class U = T> optional &operator=(U &&);
111 template <class U> optional &operator=(const optional<U> &);
112 template <class U> optional &operator=(optional<U> &&);
113 template <class... Args> T& emplace(Args &&...);
114 template <class U, class... Args>
115 T& emplace(initializer_list<U>, Args &&...);
118 void swap(optional &) noexcept(see below );
120 // 23.6.3.5, observers
121 constexpr T const *operator->() const;
122 constexpr T *operator->();
123 constexpr T const &operator*() const &;
124 constexpr T &operator*() &;
125 constexpr T &&operator*() &&;
126 constexpr const T &&operator*() const &&;
127 constexpr explicit operator bool() const noexcept;
128 constexpr bool has_value() const noexcept;
129 constexpr T const &value() const &;
130 constexpr T &value() &;
131 constexpr T &&value() &&;
132 constexpr const T &&value() const &&;
133 template <class U> constexpr T value_or(U &&) const &;
134 template <class U> constexpr T value_or(U &&) &&;
136 // 23.6.3.6, modifiers
137 void reset() noexcept;
140 T *val; // exposition only
148 #include <__functional_base>
149 #include <functional>
150 #include <initializer_list>
153 #include <type_traits>
156 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
157 #pragma GCC system_header
161 #include <__undef_macros>
164 namespace std // purposefully not using versioning namespace
167 class _LIBCPP_EXCEPTION_ABI bad_optional_access
171 // Get the key function ~bad_optional_access() into the dylib
172 virtual ~bad_optional_access() _NOEXCEPT;
173 virtual const char* what() const _NOEXCEPT;
178 #if _LIBCPP_STD_VER > 14
180 _LIBCPP_BEGIN_NAMESPACE_STD
183 inline _LIBCPP_INLINE_VISIBILITY
184 void __throw_bad_optional_access() {
185 #ifndef _LIBCPP_NO_EXCEPTIONS
186 throw bad_optional_access();
194 struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; };
195 _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
198 /* inline */ constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}};
200 template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
201 struct __optional_destruct_base;
204 struct __optional_destruct_base<_Tp, false>
206 typedef _Tp value_type;
207 static_assert(is_object_v<value_type>,
208 "instantiation of optional with a non-object type is undefined behavior");
216 _LIBCPP_INLINE_VISIBILITY
217 ~__optional_destruct_base()
220 __val_.~value_type();
223 _LIBCPP_INLINE_VISIBILITY
224 constexpr __optional_destruct_base() noexcept
228 template <class... _Args>
229 _LIBCPP_INLINE_VISIBILITY
230 constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
231 : __val_(_VSTD::forward<_Args>(__args)...),
234 _LIBCPP_INLINE_VISIBILITY
235 void reset() noexcept
239 __val_.~value_type();
246 struct __optional_destruct_base<_Tp, true>
248 typedef _Tp value_type;
249 static_assert(is_object_v<value_type>,
250 "instantiation of optional with a non-object type is undefined behavior");
258 _LIBCPP_INLINE_VISIBILITY
259 constexpr __optional_destruct_base() noexcept
263 template <class... _Args>
264 _LIBCPP_INLINE_VISIBILITY
265 constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
266 : __val_(_VSTD::forward<_Args>(__args)...),
269 _LIBCPP_INLINE_VISIBILITY
270 void reset() noexcept
279 template <class _Tp, bool = is_reference<_Tp>::value>
280 struct __optional_storage_base : __optional_destruct_base<_Tp>
282 using __base = __optional_destruct_base<_Tp>;
283 using value_type = _Tp;
284 using __base::__base;
286 _LIBCPP_INLINE_VISIBILITY
287 constexpr bool has_value() const noexcept
289 return this->__engaged_;
292 _LIBCPP_INLINE_VISIBILITY
293 constexpr value_type& __get() & noexcept
297 _LIBCPP_INLINE_VISIBILITY
298 constexpr const value_type& __get() const& noexcept
302 _LIBCPP_INLINE_VISIBILITY
303 constexpr value_type&& __get() && noexcept
305 return _VSTD::move(this->__val_);
307 _LIBCPP_INLINE_VISIBILITY
308 constexpr const value_type&& __get() const&& noexcept
310 return _VSTD::move(this->__val_);
313 template <class... _Args>
314 _LIBCPP_INLINE_VISIBILITY
315 void __construct(_Args&&... __args)
317 _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
318 ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
319 this->__engaged_ = true;
322 template <class _That>
323 _LIBCPP_INLINE_VISIBILITY
324 void __construct_from(_That&& __opt)
326 if (__opt.has_value())
327 __construct(_VSTD::forward<_That>(__opt).__get());
330 template <class _That>
331 _LIBCPP_INLINE_VISIBILITY
332 void __assign_from(_That&& __opt)
334 if (this->__engaged_ == __opt.has_value())
336 if (this->__engaged_)
337 this->__val_ = _VSTD::forward<_That>(__opt).__get();
341 if (this->__engaged_)
344 __construct(_VSTD::forward<_That>(__opt).__get());
349 // optional<T&> is currently required ill-formed, however it may to be in the
350 // future. For this reason it has already been implemented to ensure we can
351 // make the change in an ABI compatible manner.
353 struct __optional_storage_base<_Tp, true>
355 using value_type = _Tp;
356 using __raw_type = remove_reference_t<_Tp>;
357 __raw_type* __value_;
360 static constexpr bool __can_bind_reference() {
361 using _RawUp = typename remove_reference<_Up>::type;
362 using _UpPtr = _RawUp*;
363 using _RawTp = typename remove_reference<_Tp>::type;
364 using _TpPtr = _RawTp*;
365 using _CheckLValueArg = integral_constant<bool,
366 (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value)
367 || is_same<_RawUp, reference_wrapper<_RawTp>>::value
368 || is_same<_RawUp, reference_wrapper<typename remove_const<_RawTp>::type>>::value
370 return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value)
371 || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value &&
372 is_convertible<_UpPtr, _TpPtr>::value);
375 _LIBCPP_INLINE_VISIBILITY
376 constexpr __optional_storage_base() noexcept
377 : __value_(nullptr) {}
379 template <class _UArg>
380 _LIBCPP_INLINE_VISIBILITY
381 constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
382 : __value_(_VSTD::addressof(__uarg))
384 static_assert(__can_bind_reference<_UArg>(),
385 "Attempted to construct a reference element in tuple from a "
386 "possible temporary");
389 _LIBCPP_INLINE_VISIBILITY
390 void reset() noexcept { __value_ = nullptr; }
392 _LIBCPP_INLINE_VISIBILITY
393 constexpr bool has_value() const noexcept
394 { return __value_ != nullptr; }
396 _LIBCPP_INLINE_VISIBILITY
397 constexpr value_type& __get() const& noexcept
398 { return *__value_; }
400 _LIBCPP_INLINE_VISIBILITY
401 constexpr value_type&& __get() const&& noexcept
402 { return _VSTD::forward<value_type>(*__value_); }
404 template <class _UArg>
405 _LIBCPP_INLINE_VISIBILITY
406 void __construct(_UArg&& __val)
408 _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
409 static_assert(__can_bind_reference<_UArg>(),
410 "Attempted to construct a reference element in tuple from a "
411 "possible temporary");
412 __value_ = _VSTD::addressof(__val);
415 template <class _That>
416 _LIBCPP_INLINE_VISIBILITY
417 void __construct_from(_That&& __opt)
419 if (__opt.has_value())
420 __construct(_VSTD::forward<_That>(__opt).__get());
423 template <class _That>
424 _LIBCPP_INLINE_VISIBILITY
425 void __assign_from(_That&& __opt)
427 if (has_value() == __opt.has_value())
430 *__value_ = _VSTD::forward<_That>(__opt).__get();
437 __construct(_VSTD::forward<_That>(__opt).__get());
442 template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value>
443 struct __optional_copy_base : __optional_storage_base<_Tp>
445 using __optional_storage_base<_Tp>::__optional_storage_base;
449 struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp>
451 using __optional_storage_base<_Tp>::__optional_storage_base;
453 _LIBCPP_INLINE_VISIBILITY
454 __optional_copy_base() = default;
456 _LIBCPP_INLINE_VISIBILITY
457 __optional_copy_base(const __optional_copy_base& __opt)
459 this->__construct_from(__opt);
462 _LIBCPP_INLINE_VISIBILITY
463 __optional_copy_base(__optional_copy_base&&) = default;
464 _LIBCPP_INLINE_VISIBILITY
465 __optional_copy_base& operator=(const __optional_copy_base&) = default;
466 _LIBCPP_INLINE_VISIBILITY
467 __optional_copy_base& operator=(__optional_copy_base&&) = default;
470 template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value>
471 struct __optional_move_base : __optional_copy_base<_Tp>
473 using __optional_copy_base<_Tp>::__optional_copy_base;
477 struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp>
479 using value_type = _Tp;
480 using __optional_copy_base<_Tp>::__optional_copy_base;
482 _LIBCPP_INLINE_VISIBILITY
483 __optional_move_base() = default;
484 _LIBCPP_INLINE_VISIBILITY
485 __optional_move_base(const __optional_move_base&) = default;
487 _LIBCPP_INLINE_VISIBILITY
488 __optional_move_base(__optional_move_base&& __opt)
489 noexcept(is_nothrow_move_constructible_v<value_type>)
491 this->__construct_from(_VSTD::move(__opt));
494 _LIBCPP_INLINE_VISIBILITY
495 __optional_move_base& operator=(const __optional_move_base&) = default;
496 _LIBCPP_INLINE_VISIBILITY
497 __optional_move_base& operator=(__optional_move_base&&) = default;
500 template <class _Tp, bool =
501 is_trivially_destructible<_Tp>::value &&
502 is_trivially_copy_constructible<_Tp>::value &&
503 is_trivially_copy_assignable<_Tp>::value>
504 struct __optional_copy_assign_base : __optional_move_base<_Tp>
506 using __optional_move_base<_Tp>::__optional_move_base;
510 struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp>
512 using __optional_move_base<_Tp>::__optional_move_base;
514 _LIBCPP_INLINE_VISIBILITY
515 __optional_copy_assign_base() = default;
516 _LIBCPP_INLINE_VISIBILITY
517 __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
518 _LIBCPP_INLINE_VISIBILITY
519 __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
521 _LIBCPP_INLINE_VISIBILITY
522 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
524 this->__assign_from(__opt);
528 _LIBCPP_INLINE_VISIBILITY
529 __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
532 template <class _Tp, bool =
533 is_trivially_destructible<_Tp>::value &&
534 is_trivially_move_constructible<_Tp>::value &&
535 is_trivially_move_assignable<_Tp>::value>
536 struct __optional_move_assign_base : __optional_copy_assign_base<_Tp>
538 using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
542 struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp>
544 using value_type = _Tp;
545 using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
547 _LIBCPP_INLINE_VISIBILITY
548 __optional_move_assign_base() = default;
549 _LIBCPP_INLINE_VISIBILITY
550 __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
551 _LIBCPP_INLINE_VISIBILITY
552 __optional_move_assign_base(__optional_move_assign_base&&) = default;
553 _LIBCPP_INLINE_VISIBILITY
554 __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
556 _LIBCPP_INLINE_VISIBILITY
557 __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
558 noexcept(is_nothrow_move_assignable_v<value_type> &&
559 is_nothrow_move_constructible_v<value_type>)
561 this->__assign_from(_VSTD::move(__opt));
567 using __optional_sfinae_ctor_base_t = __sfinae_ctor_base<
568 is_copy_constructible<_Tp>::value,
569 is_move_constructible<_Tp>::value
573 using __optional_sfinae_assign_base_t = __sfinae_assign_base<
574 (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
575 (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value)
580 : private __optional_move_assign_base<_Tp>
581 , private __optional_sfinae_ctor_base_t<_Tp>
582 , private __optional_sfinae_assign_base_t<_Tp>
584 using __base = __optional_move_assign_base<_Tp>;
586 using value_type = _Tp;
589 // Disable the reference extension using this static assert.
590 static_assert(!is_same_v<value_type, in_place_t>,
591 "instantiation of optional with in_place_t is ill-formed");
592 static_assert(!is_same_v<__uncvref_t<value_type>, nullopt_t>,
593 "instantiation of optional with nullopt_t is ill-formed");
594 static_assert(!is_reference_v<value_type>,
595 "instantiation of optional with a reference type is ill-formed");
596 static_assert(is_destructible_v<value_type>,
597 "instantiation of optional with a non-destructible type is ill-formed");
599 // LWG2756: conditionally explicit conversion from _Up
600 struct _CheckOptionalArgsConstructor {
602 static constexpr bool __enable_implicit() {
603 return is_constructible_v<_Tp, _Up&&> &&
604 is_convertible_v<_Up&&, _Tp>;
608 static constexpr bool __enable_explicit() {
609 return is_constructible_v<_Tp, _Up&&> &&
610 !is_convertible_v<_Up&&, _Tp>;
614 using _CheckOptionalArgsCtor = conditional_t<
615 !is_same_v<decay_t<_Up>, in_place_t> &&
616 !is_same_v<decay_t<_Up>, optional>,
617 _CheckOptionalArgsConstructor,
618 __check_tuple_constructor_fail
620 template <class _QualUp>
621 struct _CheckOptionalLikeConstructor {
622 template <class _Up, class _Opt = optional<_Up>>
623 using __check_constructible_from_opt = __lazy_or<
624 is_constructible<_Tp, _Opt&>,
625 is_constructible<_Tp, _Opt const&>,
626 is_constructible<_Tp, _Opt&&>,
627 is_constructible<_Tp, _Opt const&&>,
628 is_convertible<_Opt&, _Tp>,
629 is_convertible<_Opt const&, _Tp>,
630 is_convertible<_Opt&&, _Tp>,
631 is_convertible<_Opt const&&, _Tp>
633 template <class _Up, class _Opt = optional<_Up>>
634 using __check_assignable_from_opt = __lazy_or<
635 is_assignable<_Tp&, _Opt&>,
636 is_assignable<_Tp&, _Opt const&>,
637 is_assignable<_Tp&, _Opt&&>,
638 is_assignable<_Tp&, _Opt const&&>
640 template <class _Up, class _QUp = _QualUp>
641 static constexpr bool __enable_implicit() {
642 return is_convertible<_QUp, _Tp>::value &&
643 !__check_constructible_from_opt<_Up>::value;
645 template <class _Up, class _QUp = _QualUp>
646 static constexpr bool __enable_explicit() {
647 return !is_convertible<_QUp, _Tp>::value &&
648 !__check_constructible_from_opt<_Up>::value;
650 template <class _Up, class _QUp = _QualUp>
651 static constexpr bool __enable_assign() {
652 // Construction and assignability of _Qup to _Tp has already been
654 return !__check_constructible_from_opt<_Up>::value &&
655 !__check_assignable_from_opt<_Up>::value;
659 template <class _Up, class _QualUp>
660 using _CheckOptionalLikeCtor = conditional_t<
662 __lazy_not<is_same<_Up, _Tp>>,
663 is_constructible<_Tp, _QualUp>
665 _CheckOptionalLikeConstructor<_QualUp>,
666 __check_tuple_constructor_fail
668 template <class _Up, class _QualUp>
669 using _CheckOptionalLikeAssign = conditional_t<
671 __lazy_not<is_same<_Up, _Tp>>,
672 is_constructible<_Tp, _QualUp>,
673 is_assignable<_Tp&, _QualUp>
675 _CheckOptionalLikeConstructor<_QualUp>,
676 __check_tuple_constructor_fail
680 _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
681 _LIBCPP_INLINE_VISIBILITY constexpr optional(const optional&) = default;
682 _LIBCPP_INLINE_VISIBILITY constexpr optional(optional&&) = default;
683 _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
685 template <class... _Args, class = enable_if_t<
686 is_constructible_v<value_type, _Args...>>
688 _LIBCPP_INLINE_VISIBILITY
689 constexpr explicit optional(in_place_t, _Args&&... __args)
690 : __base(in_place, _VSTD::forward<_Args>(__args)...) {}
692 template <class _Up, class... _Args, class = enable_if_t<
693 is_constructible_v<value_type, initializer_list<_Up>&, _Args...>>
695 _LIBCPP_INLINE_VISIBILITY
696 constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
697 : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}
699 template <class _Up = value_type, enable_if_t<
700 _CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>()
702 _LIBCPP_INLINE_VISIBILITY
703 constexpr optional(_Up&& __v)
704 : __base(in_place, _VSTD::forward<_Up>(__v)) {}
706 template <class _Up, enable_if_t<
707 _CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>()
709 _LIBCPP_INLINE_VISIBILITY
710 constexpr explicit optional(_Up&& __v)
711 : __base(in_place, _VSTD::forward<_Up>(__v)) {}
713 // LWG2756: conditionally explicit conversion from const optional<_Up>&
714 template <class _Up, enable_if_t<
715 _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>()
717 _LIBCPP_INLINE_VISIBILITY
718 optional(const optional<_Up>& __v)
720 this->__construct_from(__v);
722 template <class _Up, enable_if_t<
723 _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>()
725 _LIBCPP_INLINE_VISIBILITY
726 explicit optional(const optional<_Up>& __v)
728 this->__construct_from(__v);
731 // LWG2756: conditionally explicit conversion from optional<_Up>&&
732 template <class _Up, enable_if_t<
733 _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>()
735 _LIBCPP_INLINE_VISIBILITY
736 optional(optional<_Up>&& __v)
738 this->__construct_from(_VSTD::move(__v));
740 template <class _Up, enable_if_t<
741 _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>()
743 _LIBCPP_INLINE_VISIBILITY
744 explicit optional(optional<_Up>&& __v)
746 this->__construct_from(_VSTD::move(__v));
749 _LIBCPP_INLINE_VISIBILITY
750 optional& operator=(nullopt_t) noexcept
756 _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default;
757 _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default;
760 template <class _Up = value_type,
763 integral_constant<bool,
764 !is_same_v<decay_t<_Up>, optional> &&
765 !(is_same_v<_Up, value_type> && is_scalar_v<value_type>)
767 is_constructible<value_type, _Up>,
768 is_assignable<value_type&, _Up>
771 _LIBCPP_INLINE_VISIBILITY
775 if (this->has_value())
776 this->__get() = _VSTD::forward<_Up>(__v);
778 this->__construct(_VSTD::forward<_Up>(__v));
783 template <class _Up, enable_if_t<
784 _CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>()
786 _LIBCPP_INLINE_VISIBILITY
788 operator=(const optional<_Up>& __v)
790 this->__assign_from(__v);
795 template <class _Up, enable_if_t<
796 _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>()
798 _LIBCPP_INLINE_VISIBILITY
800 operator=(optional<_Up>&& __v)
802 this->__assign_from(_VSTD::move(__v));
806 template <class... _Args,
809 is_constructible_v<value_type, _Args...>
812 _LIBCPP_INLINE_VISIBILITY
814 emplace(_Args&&... __args)
817 this->__construct(_VSTD::forward<_Args>(__args)...);
818 return this->__get();
821 template <class _Up, class... _Args,
824 is_constructible_v<value_type, initializer_list<_Up>&, _Args...>
827 _LIBCPP_INLINE_VISIBILITY
829 emplace(initializer_list<_Up> __il, _Args&&... __args)
832 this->__construct(__il, _VSTD::forward<_Args>(__args)...);
833 return this->__get();
836 _LIBCPP_INLINE_VISIBILITY
837 void swap(optional& __opt)
838 noexcept(is_nothrow_move_constructible_v<value_type> &&
839 is_nothrow_swappable_v<value_type>)
841 if (this->has_value() == __opt.has_value())
844 if (this->has_value())
845 swap(this->__get(), __opt.__get());
849 if (this->has_value())
851 __opt.__construct(_VSTD::move(this->__get()));
856 this->__construct(_VSTD::move(__opt.__get()));
862 _LIBCPP_INLINE_VISIBILITY
864 add_pointer_t<value_type const>
867 _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value");
868 #ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
869 return _VSTD::addressof(this->__get());
871 return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get());
875 _LIBCPP_INLINE_VISIBILITY
877 add_pointer_t<value_type>
880 _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value");
881 #ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
882 return _VSTD::addressof(this->__get());
884 return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get());
888 _LIBCPP_INLINE_VISIBILITY
893 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
894 return this->__get();
897 _LIBCPP_INLINE_VISIBILITY
902 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
903 return this->__get();
906 _LIBCPP_INLINE_VISIBILITY
911 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
912 return _VSTD::move(this->__get());
915 _LIBCPP_INLINE_VISIBILITY
920 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
921 return _VSTD::move(this->__get());
924 _LIBCPP_INLINE_VISIBILITY
925 constexpr explicit operator bool() const noexcept { return has_value(); }
927 using __base::has_value;
930 _LIBCPP_INLINE_VISIBILITY
931 constexpr value_type const& value() const&
933 if (!this->has_value())
934 __throw_bad_optional_access();
935 return this->__get();
938 _LIBCPP_INLINE_VISIBILITY
939 constexpr value_type& value() &
941 if (!this->has_value())
942 __throw_bad_optional_access();
943 return this->__get();
946 _LIBCPP_INLINE_VISIBILITY
947 constexpr value_type&& value() &&
949 if (!this->has_value())
950 __throw_bad_optional_access();
951 return _VSTD::move(this->__get());
954 _LIBCPP_INLINE_VISIBILITY
955 constexpr value_type const&& value() const&&
957 if (!this->has_value())
958 __throw_bad_optional_access();
959 return _VSTD::move(this->__get());
963 _LIBCPP_INLINE_VISIBILITY
964 constexpr value_type value_or(_Up&& __v) const&
966 static_assert(is_copy_constructible_v<value_type>,
967 "optional<T>::value_or: T must be copy constructible");
968 static_assert(is_convertible_v<_Up, value_type>,
969 "optional<T>::value_or: U must be convertible to T");
970 return this->has_value() ? this->__get() :
971 static_cast<value_type>(_VSTD::forward<_Up>(__v));
975 _LIBCPP_INLINE_VISIBILITY
976 constexpr value_type value_or(_Up&& __v) &&
978 static_assert(is_move_constructible_v<value_type>,
979 "optional<T>::value_or: T must be move constructible");
980 static_assert(is_convertible_v<_Up, value_type>,
981 "optional<T>::value_or: U must be convertible to T");
982 return this->has_value() ? _VSTD::move(this->__get()) :
983 static_cast<value_type>(_VSTD::forward<_Up>(__v));
990 _LIBCPP_INLINE_VISIBILITY
992 __operator_arrow(true_type, _Up& __x)
994 return _VSTD::addressof(__x);
998 _LIBCPP_INLINE_VISIBILITY
999 static constexpr _Up*
1000 __operator_arrow(false_type, _Up& __x)
1006 // Comparisons between optionals
1007 template <class _Tp, class _Up>
1008 _LIBCPP_INLINE_VISIBILITY constexpr
1010 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
1011 _VSTD::declval<const _Up&>()), bool>,
1014 operator==(const optional<_Tp>& __x, const optional<_Up>& __y)
1016 if (static_cast<bool>(__x) != static_cast<bool>(__y))
1018 if (!static_cast<bool>(__x))
1020 return *__x == *__y;
1023 template <class _Tp, class _Up>
1024 _LIBCPP_INLINE_VISIBILITY constexpr
1026 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
1027 _VSTD::declval<const _Up&>()), bool>,
1030 operator!=(const optional<_Tp>& __x, const optional<_Up>& __y)
1032 if (static_cast<bool>(__x) != static_cast<bool>(__y))
1034 if (!static_cast<bool>(__x))
1036 return *__x != *__y;
1039 template <class _Tp, class _Up>
1040 _LIBCPP_INLINE_VISIBILITY constexpr
1042 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
1043 _VSTD::declval<const _Up&>()), bool>,
1046 operator<(const optional<_Tp>& __x, const optional<_Up>& __y)
1048 if (!static_cast<bool>(__y))
1050 if (!static_cast<bool>(__x))
1055 template <class _Tp, class _Up>
1056 _LIBCPP_INLINE_VISIBILITY constexpr
1058 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
1059 _VSTD::declval<const _Up&>()), bool>,
1062 operator>(const optional<_Tp>& __x, const optional<_Up>& __y)
1064 if (!static_cast<bool>(__x))
1066 if (!static_cast<bool>(__y))
1071 template <class _Tp, class _Up>
1072 _LIBCPP_INLINE_VISIBILITY constexpr
1074 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
1075 _VSTD::declval<const _Up&>()), bool>,
1078 operator<=(const optional<_Tp>& __x, const optional<_Up>& __y)
1080 if (!static_cast<bool>(__x))
1082 if (!static_cast<bool>(__y))
1084 return *__x <= *__y;
1087 template <class _Tp, class _Up>
1088 _LIBCPP_INLINE_VISIBILITY constexpr
1090 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
1091 _VSTD::declval<const _Up&>()), bool>,
1094 operator>=(const optional<_Tp>& __x, const optional<_Up>& __y)
1096 if (!static_cast<bool>(__y))
1098 if (!static_cast<bool>(__x))
1100 return *__x >= *__y;
1103 // Comparisons with nullopt
1104 template <class _Tp>
1105 _LIBCPP_INLINE_VISIBILITY constexpr
1107 operator==(const optional<_Tp>& __x, nullopt_t) noexcept
1109 return !static_cast<bool>(__x);
1112 template <class _Tp>
1113 _LIBCPP_INLINE_VISIBILITY constexpr
1115 operator==(nullopt_t, const optional<_Tp>& __x) noexcept
1117 return !static_cast<bool>(__x);
1120 template <class _Tp>
1121 _LIBCPP_INLINE_VISIBILITY constexpr
1123 operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
1125 return static_cast<bool>(__x);
1128 template <class _Tp>
1129 _LIBCPP_INLINE_VISIBILITY constexpr
1131 operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
1133 return static_cast<bool>(__x);
1136 template <class _Tp>
1137 _LIBCPP_INLINE_VISIBILITY constexpr
1139 operator<(const optional<_Tp>&, nullopt_t) noexcept
1144 template <class _Tp>
1145 _LIBCPP_INLINE_VISIBILITY constexpr
1147 operator<(nullopt_t, const optional<_Tp>& __x) noexcept
1149 return static_cast<bool>(__x);
1152 template <class _Tp>
1153 _LIBCPP_INLINE_VISIBILITY constexpr
1155 operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
1157 return !static_cast<bool>(__x);
1160 template <class _Tp>
1161 _LIBCPP_INLINE_VISIBILITY constexpr
1163 operator<=(nullopt_t, const optional<_Tp>&) noexcept
1168 template <class _Tp>
1169 _LIBCPP_INLINE_VISIBILITY constexpr
1171 operator>(const optional<_Tp>& __x, nullopt_t) noexcept
1173 return static_cast<bool>(__x);
1176 template <class _Tp>
1177 _LIBCPP_INLINE_VISIBILITY constexpr
1179 operator>(nullopt_t, const optional<_Tp>&) noexcept
1184 template <class _Tp>
1185 _LIBCPP_INLINE_VISIBILITY constexpr
1187 operator>=(const optional<_Tp>&, nullopt_t) noexcept
1192 template <class _Tp>
1193 _LIBCPP_INLINE_VISIBILITY constexpr
1195 operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
1197 return !static_cast<bool>(__x);
1200 // Comparisons with T
1201 template <class _Tp, class _Up>
1202 _LIBCPP_INLINE_VISIBILITY constexpr
1204 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
1205 _VSTD::declval<const _Up&>()), bool>,
1208 operator==(const optional<_Tp>& __x, const _Up& __v)
1210 return static_cast<bool>(__x) ? *__x == __v : false;
1213 template <class _Tp, class _Up>
1214 _LIBCPP_INLINE_VISIBILITY constexpr
1216 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
1217 _VSTD::declval<const _Up&>()), bool>,
1220 operator==(const _Tp& __v, const optional<_Up>& __x)
1222 return static_cast<bool>(__x) ? __v == *__x : false;
1225 template <class _Tp, class _Up>
1226 _LIBCPP_INLINE_VISIBILITY constexpr
1228 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
1229 _VSTD::declval<const _Up&>()), bool>,
1232 operator!=(const optional<_Tp>& __x, const _Up& __v)
1234 return static_cast<bool>(__x) ? *__x != __v : true;
1237 template <class _Tp, class _Up>
1238 _LIBCPP_INLINE_VISIBILITY constexpr
1240 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
1241 _VSTD::declval<const _Up&>()), bool>,
1244 operator!=(const _Tp& __v, const optional<_Up>& __x)
1246 return static_cast<bool>(__x) ? __v != *__x : true;
1249 template <class _Tp, class _Up>
1250 _LIBCPP_INLINE_VISIBILITY constexpr
1252 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
1253 _VSTD::declval<const _Up&>()), bool>,
1256 operator<(const optional<_Tp>& __x, const _Up& __v)
1258 return static_cast<bool>(__x) ? *__x < __v : true;
1261 template <class _Tp, class _Up>
1262 _LIBCPP_INLINE_VISIBILITY constexpr
1264 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
1265 _VSTD::declval<const _Up&>()), bool>,
1268 operator<(const _Tp& __v, const optional<_Up>& __x)
1270 return static_cast<bool>(__x) ? __v < *__x : false;
1273 template <class _Tp, class _Up>
1274 _LIBCPP_INLINE_VISIBILITY constexpr
1276 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
1277 _VSTD::declval<const _Up&>()), bool>,
1280 operator<=(const optional<_Tp>& __x, const _Up& __v)
1282 return static_cast<bool>(__x) ? *__x <= __v : true;
1285 template <class _Tp, class _Up>
1286 _LIBCPP_INLINE_VISIBILITY constexpr
1288 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
1289 _VSTD::declval<const _Up&>()), bool>,
1292 operator<=(const _Tp& __v, const optional<_Up>& __x)
1294 return static_cast<bool>(__x) ? __v <= *__x : false;
1297 template <class _Tp, class _Up>
1298 _LIBCPP_INLINE_VISIBILITY constexpr
1300 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
1301 _VSTD::declval<const _Up&>()), bool>,
1304 operator>(const optional<_Tp>& __x, const _Up& __v)
1306 return static_cast<bool>(__x) ? *__x > __v : false;
1309 template <class _Tp, class _Up>
1310 _LIBCPP_INLINE_VISIBILITY constexpr
1312 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
1313 _VSTD::declval<const _Up&>()), bool>,
1316 operator>(const _Tp& __v, const optional<_Up>& __x)
1318 return static_cast<bool>(__x) ? __v > *__x : true;
1321 template <class _Tp, class _Up>
1322 _LIBCPP_INLINE_VISIBILITY constexpr
1324 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
1325 _VSTD::declval<const _Up&>()), bool>,
1328 operator>=(const optional<_Tp>& __x, const _Up& __v)
1330 return static_cast<bool>(__x) ? *__x >= __v : false;
1333 template <class _Tp, class _Up>
1334 _LIBCPP_INLINE_VISIBILITY constexpr
1336 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
1337 _VSTD::declval<const _Up&>()), bool>,
1340 operator>=(const _Tp& __v, const optional<_Up>& __x)
1342 return static_cast<bool>(__x) ? __v >= *__x : true;
1346 template <class _Tp>
1347 inline _LIBCPP_INLINE_VISIBILITY
1349 is_move_constructible_v<_Tp> && is_swappable_v<_Tp>,
1352 swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
1357 template <class _Tp>
1358 _LIBCPP_INLINE_VISIBILITY constexpr
1359 optional<decay_t<_Tp>> make_optional(_Tp&& __v)
1361 return optional<decay_t<_Tp>>(_VSTD::forward<_Tp>(__v));
1364 template <class _Tp, class... _Args>
1365 _LIBCPP_INLINE_VISIBILITY constexpr
1366 optional<_Tp> make_optional(_Args&&... __args)
1368 return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...);
1371 template <class _Tp, class _Up, class... _Args>
1372 _LIBCPP_INLINE_VISIBILITY constexpr
1373 optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args)
1375 return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...);
1378 template <class _Tp>
1379 struct _LIBCPP_TEMPLATE_VIS hash<
1380 __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>>
1383 typedef optional<_Tp> argument_type;
1384 typedef size_t result_type;
1386 _LIBCPP_INLINE_VISIBILITY
1387 result_type operator()(const argument_type& __opt) const
1389 return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
1393 _LIBCPP_END_NAMESPACE_STD
1395 #endif // _LIBCPP_STD_VER > 14
1399 #endif // _LIBCPP_OPTIONAL