1 // <optional> -*- C++ -*-
3 // Copyright (C) 2013-2018 Free Software Foundation, Inc.
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
25 /** @file include/optional
26 * This is a Standard C++ Library header.
29 #ifndef _GLIBCXX_OPTIONAL
30 #define _GLIBCXX_OPTIONAL 1
32 #pragma GCC system_header
34 #if __cplusplus >= 201703L
37 #include <type_traits>
40 #include <initializer_list>
41 #include <bits/functexcept.h>
42 #include <bits/functional_hash.h>
43 #include <bits/enable_special_members.h>
45 namespace std _GLIBCXX_VISIBILITY(default)
47 _GLIBCXX_BEGIN_NAMESPACE_VERSION
50 * @addtogroup utilities
54 #define __cpp_lib_optional 201603
56 template<typename _Tp>
59 /// Tag type to disengage optional objects.
62 // Do not user-declare default constructor at all for
63 // optional_value = {} syntax to work.
64 // nullopt_t() = delete;
66 // Used for constructing nullopt.
67 enum class _Construct { _Token };
69 // Must be constexpr for nullopt_t to be literal.
70 explicit constexpr nullopt_t(_Construct) { }
73 /// Tag to disengage optional objects.
74 inline constexpr nullopt_t nullopt { nullopt_t::_Construct::_Token };
77 * @brief Exception class thrown when a disengaged optional object is
81 class bad_optional_access : public exception
84 bad_optional_access() { }
86 virtual const char* what() const noexcept override
87 { return "bad optional access"; }
89 virtual ~bad_optional_access() noexcept = default;
93 __throw_bad_optional_access()
94 __attribute__((__noreturn__));
96 // XXX Does not belong here.
98 __throw_bad_optional_access()
99 { _GLIBCXX_THROW_OR_ABORT(bad_optional_access()); }
102 // Payload for optionals with non-trivial destructor.
103 template <typename _Tp,
104 bool /*_HasTrivialDestructor*/ =
105 is_trivially_destructible_v<_Tp>,
106 bool /*_HasTrivialCopyAssignment*/ =
107 is_trivially_copy_assignable_v<_Tp>,
108 bool /*_HasTrivialMoveAssignment*/ =
109 is_trivially_move_assignable_v<_Tp>>
110 struct _Optional_payload
112 constexpr _Optional_payload() noexcept : _M_empty() { }
114 template <typename... _Args>
116 _Optional_payload(in_place_t, _Args&&... __args)
117 : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true) { }
119 template<typename _Up, typename... _Args>
121 _Optional_payload(std::initializer_list<_Up> __il,
123 : _M_payload(__il, std::forward<_Args>(__args)...),
128 _Optional_payload(bool __engaged, const _Optional_payload& __other)
129 : _Optional_payload(__other)
133 _Optional_payload(bool __engaged, _Optional_payload&& __other)
134 : _Optional_payload(std::move(__other))
138 _Optional_payload(const _Optional_payload& __other)
140 if (__other._M_engaged)
141 this->_M_construct(__other._M_payload);
145 _Optional_payload(_Optional_payload&& __other)
147 if (__other._M_engaged)
148 this->_M_construct(std::move(__other._M_payload));
152 operator=(const _Optional_payload& __other)
154 if (this->_M_engaged && __other._M_engaged)
155 this->_M_get() = __other._M_get();
158 if (__other._M_engaged)
159 this->_M_construct(__other._M_get());
167 operator=(_Optional_payload&& __other)
168 noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
169 is_nothrow_move_assignable<_Tp>>)
171 if (this->_M_engaged && __other._M_engaged)
172 this->_M_get() = std::move(__other._M_get());
175 if (__other._M_engaged)
176 this->_M_construct(std::move(__other._M_get()));
183 using _Stored_type = remove_const_t<_Tp>;
185 struct _Empty_byte { };
188 _Empty_byte _M_empty;
189 _Stored_type _M_payload;
191 bool _M_engaged = false;
196 _M_payload.~_Stored_type();
199 template<typename... _Args>
201 _M_construct(_Args&&... __args)
202 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
204 ::new ((void *) std::__addressof(this->_M_payload))
205 _Stored_type(std::forward<_Args>(__args)...);
206 this->_M_engaged = true;
209 // The _M_get operations have _M_engaged as a precondition.
212 { return this->_M_payload; }
215 _M_get() const noexcept
216 { return this->_M_payload; }
218 // _M_reset is a 'safe' operation with no precondition.
222 if (this->_M_engaged)
224 this->_M_engaged = false;
225 this->_M_payload.~_Stored_type();
230 // Payload for potentially-constexpr optionals.
231 template <typename _Tp>
232 struct _Optional_payload<_Tp, true, true, true>
234 constexpr _Optional_payload() noexcept
235 : _M_empty(), _M_engaged(false) { }
237 template<typename... _Args>
239 _Optional_payload(in_place_t, _Args&&... __args)
240 : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
243 template<typename _Up, typename... _Args>
245 _Optional_payload(std::initializer_list<_Up> __il,
247 : _M_payload(__il, std::forward<_Args>(__args)...),
251 template <class _Up> struct __ctor_tag {};
254 _Optional_payload(__ctor_tag<bool>, const _Tp& __other)
255 : _M_payload(__other), _M_engaged(true)
258 constexpr _Optional_payload(__ctor_tag<void>) noexcept
259 : _M_empty(), _M_engaged(false)
262 constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
263 : _M_payload(std::move(__other)), _M_engaged(true)
267 _Optional_payload(bool __engaged, const _Optional_payload& __other)
268 : _Optional_payload(__engaged ?
269 _Optional_payload(__ctor_tag<bool>{},
270 __other._M_payload) :
271 _Optional_payload(__ctor_tag<void>{}))
275 _Optional_payload(bool __engaged, _Optional_payload&& __other)
276 : _Optional_payload(__engaged
277 ? _Optional_payload(__ctor_tag<bool>{},
278 std::move(__other._M_payload))
279 : _Optional_payload(__ctor_tag<void>{}))
282 using _Stored_type = remove_const_t<_Tp>;
284 struct _Empty_byte { };
287 _Empty_byte _M_empty;
288 _Stored_type _M_payload;
293 // Payload for optionals with non-trivial copy assignment.
294 template <typename _Tp>
295 struct _Optional_payload<_Tp, true, false, true>
297 constexpr _Optional_payload() noexcept
298 : _M_empty(), _M_engaged(false) { }
300 template<typename... _Args>
302 _Optional_payload(in_place_t, _Args&&... __args)
303 : _M_payload(std::forward<_Args>(__args)...), _M_engaged(true)
306 template<typename _Up, typename... _Args>
308 _Optional_payload(std::initializer_list<_Up> __il,
310 : _M_payload(__il, std::forward<_Args>(__args)...),
314 template <class _Up> struct __ctor_tag {};
316 constexpr _Optional_payload(__ctor_tag<bool>, const _Tp& __other)
317 : _M_payload(__other),
321 constexpr _Optional_payload(__ctor_tag<void>) noexcept
322 : _M_empty(), _M_engaged(false)
325 constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
326 : _M_payload(std::move(__other)),
331 _Optional_payload(bool __engaged, const _Optional_payload& __other)
332 : _Optional_payload(__engaged ?
333 _Optional_payload(__ctor_tag<bool>{},
334 __other._M_payload) :
335 _Optional_payload(__ctor_tag<void>{}))
339 _Optional_payload(bool __engaged, _Optional_payload&& __other)
340 : _Optional_payload(__engaged
341 ? _Optional_payload(__ctor_tag<bool>{},
342 std::move(__other._M_payload))
343 : _Optional_payload(__ctor_tag<void>{}))
346 _Optional_payload(const _Optional_payload&) = default;
347 _Optional_payload(_Optional_payload&&) = default;
350 operator=(const _Optional_payload& __other)
352 if (this->_M_engaged && __other._M_engaged)
353 this->_M_get() = __other._M_get();
356 if (__other._M_engaged)
357 this->_M_construct(__other._M_get());
365 operator=(_Optional_payload&& __other) = default;
367 using _Stored_type = remove_const_t<_Tp>;
369 struct _Empty_byte { };
372 _Empty_byte _M_empty;
373 _Stored_type _M_payload;
377 template<typename... _Args>
379 _M_construct(_Args&&... __args)
380 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
382 ::new ((void *) std::__addressof(this->_M_payload))
383 _Stored_type(std::forward<_Args>(__args)...);
384 this->_M_engaged = true;
387 // The _M_get operations have _M_engaged as a precondition.
390 { return this->_M_payload; }
393 _M_get() const noexcept
394 { return this->_M_payload; }
396 // _M_reset is a 'safe' operation with no precondition.
400 if (this->_M_engaged)
402 this->_M_engaged = false;
403 this->_M_payload.~_Stored_type();
408 // Payload for optionals with non-trivial move assignment.
409 template <typename _Tp>
410 struct _Optional_payload<_Tp, true, true, false>
412 constexpr _Optional_payload() noexcept
413 : _M_empty(), _M_engaged(false) { }
415 template<typename... _Args>
417 _Optional_payload(in_place_t, _Args&&... __args)
418 : _M_payload(std::forward<_Args>(__args)...),
422 template<typename _Up, typename... _Args>
424 _Optional_payload(std::initializer_list<_Up> __il,
426 : _M_payload(__il, std::forward<_Args>(__args)...),
430 template <class _Up> struct __ctor_tag {};
433 _Optional_payload(__ctor_tag<bool>, const _Tp& __other)
434 : _M_payload(__other),
438 constexpr _Optional_payload(__ctor_tag<void>) noexcept
439 : _M_empty(), _M_engaged(false)
442 constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
443 : _M_payload(std::move(__other)),
448 _Optional_payload(bool __engaged, const _Optional_payload& __other)
449 : _Optional_payload(__engaged ?
450 _Optional_payload(__ctor_tag<bool>{},
451 __other._M_payload) :
452 _Optional_payload(__ctor_tag<void>{}))
456 _Optional_payload(bool __engaged, _Optional_payload&& __other)
457 : _Optional_payload(__engaged
458 ? _Optional_payload(__ctor_tag<bool>{},
459 std::move(__other._M_payload))
460 : _Optional_payload(__ctor_tag<void>{}))
463 _Optional_payload(const _Optional_payload&) = default;
464 _Optional_payload(_Optional_payload&&) = default;
467 operator=(const _Optional_payload& __other) = default;
470 operator=(_Optional_payload&& __other)
471 noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
472 is_nothrow_move_assignable<_Tp>>)
474 if (this->_M_engaged && __other._M_engaged)
475 this->_M_get() = std::move(__other._M_get());
478 if (__other._M_engaged)
479 this->_M_construct(std::move(__other._M_get()));
486 using _Stored_type = remove_const_t<_Tp>;
488 struct _Empty_byte { };
491 _Empty_byte _M_empty;
492 _Stored_type _M_payload;
496 template<typename... _Args>
498 _M_construct(_Args&&... __args)
499 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
501 ::new ((void *) std::__addressof(this->_M_payload))
502 _Stored_type(std::forward<_Args>(__args)...);
503 this->_M_engaged = true;
506 // The _M_get operations have _M_engaged as a precondition.
509 { return this->_M_payload; }
512 _M_get() const noexcept
513 { return this->_M_payload; }
515 // _M_reset is a 'safe' operation with no precondition.
519 if (this->_M_engaged)
521 this->_M_engaged = false;
522 this->_M_payload.~_Stored_type();
527 // Payload for optionals with non-trivial copy and move assignment.
528 template <typename _Tp>
529 struct _Optional_payload<_Tp, true, false, false>
531 constexpr _Optional_payload() noexcept
532 : _M_empty(), _M_engaged(false) {}
534 template<typename... _Args>
536 _Optional_payload(in_place_t, _Args&&... __args)
537 : _M_payload(std::forward<_Args>(__args)...),
541 template<typename _Up, typename... _Args>
543 _Optional_payload(std::initializer_list<_Up> __il,
545 : _M_payload(__il, std::forward<_Args>(__args)...),
549 template <class _Up> struct __ctor_tag {};
551 constexpr _Optional_payload(__ctor_tag<bool>, const _Tp& __other)
552 : _M_payload(__other),
556 constexpr _Optional_payload(__ctor_tag<void>) noexcept
557 : _M_empty(), _M_engaged(false)
560 constexpr _Optional_payload(__ctor_tag<bool>, _Tp&& __other)
561 : _M_payload(std::move(__other)),
566 _Optional_payload(bool __engaged, const _Optional_payload& __other)
567 : _Optional_payload(__engaged ?
568 _Optional_payload(__ctor_tag<bool>{},
569 __other._M_payload) :
570 _Optional_payload(__ctor_tag<void>{}))
574 _Optional_payload(bool __engaged, _Optional_payload&& __other)
575 : _Optional_payload(__engaged
576 ? _Optional_payload(__ctor_tag<bool>{},
577 std::move(__other._M_payload))
578 : _Optional_payload(__ctor_tag<void>{}))
581 _Optional_payload(const _Optional_payload&) = default;
582 _Optional_payload(_Optional_payload&&) = default;
585 operator=(const _Optional_payload& __other)
587 if (this->_M_engaged && __other._M_engaged)
588 this->_M_get() = __other._M_get();
591 if (__other._M_engaged)
592 this->_M_construct(__other._M_get());
600 operator=(_Optional_payload&& __other)
601 noexcept(__and_v<is_nothrow_move_constructible<_Tp>,
602 is_nothrow_move_assignable<_Tp>>)
604 if (this->_M_engaged && __other._M_engaged)
605 this->_M_get() = std::move(__other._M_get());
608 if (__other._M_engaged)
609 this->_M_construct(std::move(__other._M_get()));
616 using _Stored_type = remove_const_t<_Tp>;
618 struct _Empty_byte { };
621 _Empty_byte _M_empty;
622 _Stored_type _M_payload;
626 template<typename... _Args>
628 _M_construct(_Args&&... __args)
629 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
631 ::new ((void *) std::__addressof(this->_M_payload))
632 _Stored_type(std::forward<_Args>(__args)...);
633 this->_M_engaged = true;
636 // The _M_get operations have _M_engaged as a precondition.
639 { return this->_M_payload; }
642 _M_get() const noexcept
643 { return this->_M_payload; }
645 // _M_reset is a 'safe' operation with no precondition.
649 if (this->_M_engaged)
651 this->_M_engaged = false;
652 this->_M_payload.~_Stored_type();
657 template<typename _Tp, typename _Dp>
658 class _Optional_base_impl
661 using _Stored_type = remove_const_t<_Tp>;
663 // The _M_construct operation has !_M_engaged as a precondition
664 // while _M_destruct has _M_engaged as a precondition.
665 template<typename... _Args>
667 _M_construct(_Args&&... __args)
668 noexcept(is_nothrow_constructible_v<_Stored_type, _Args...>)
671 (std::__addressof(static_cast<_Dp*>(this)->_M_payload._M_payload))
672 _Stored_type(std::forward<_Args>(__args)...);
673 static_cast<_Dp*>(this)->_M_payload._M_engaged = true;
677 _M_destruct() noexcept
679 static_cast<_Dp*>(this)->_M_payload._M_engaged = false;
680 static_cast<_Dp*>(this)->_M_payload._M_payload.~_Stored_type();
683 // _M_reset is a 'safe' operation with no precondition.
687 if (static_cast<_Dp*>(this)->_M_payload._M_engaged)
688 static_cast<_Dp*>(this)->_M_destruct();
693 * @brief Class template that takes care of copy/move constructors
696 * Such a separate base class template is necessary in order to
697 * conditionally make copy/move constructors trivial.
698 * @see optional, _Enable_special_members
700 template<typename _Tp,
701 bool = is_trivially_copy_constructible_v<_Tp>,
702 bool = is_trivially_move_constructible_v<_Tp>>
704 // protected inheritance because optional needs to reach that base too
705 : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
707 friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
710 // Constructors for disengaged optionals.
711 constexpr _Optional_base() = default;
713 // Constructors for engaged optionals.
714 template<typename... _Args,
715 enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
716 constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
717 : _M_payload(in_place,
718 std::forward<_Args>(__args)...) { }
720 template<typename _Up, typename... _Args,
721 enable_if_t<is_constructible_v<_Tp,
722 initializer_list<_Up>&,
723 _Args&&...>, bool> = false>
724 constexpr explicit _Optional_base(in_place_t,
725 initializer_list<_Up> __il,
727 : _M_payload(in_place,
728 __il, std::forward<_Args>(__args)...)
731 // Copy and move constructors.
732 constexpr _Optional_base(const _Optional_base& __other)
733 : _M_payload(__other._M_payload._M_engaged,
737 constexpr _Optional_base(_Optional_base&& __other)
738 noexcept(is_nothrow_move_constructible_v<_Tp>)
739 : _M_payload(__other._M_payload._M_engaged,
740 std::move(__other._M_payload))
743 // Assignment operators.
744 _Optional_base& operator=(const _Optional_base&) = default;
745 _Optional_base& operator=(_Optional_base&&) = default;
749 constexpr bool _M_is_engaged() const noexcept
750 { return this->_M_payload._M_engaged; }
752 // The _M_get operations have _M_engaged as a precondition.
756 __glibcxx_assert(this->_M_is_engaged());
757 return this->_M_payload._M_payload;
761 _M_get() const noexcept
763 __glibcxx_assert(this->_M_is_engaged());
764 return this->_M_payload._M_payload;
768 _Optional_payload<_Tp> _M_payload;
771 template<typename _Tp>
772 class _Optional_base<_Tp, false, true>
773 : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
775 friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
778 // Constructors for disengaged optionals.
779 constexpr _Optional_base() = default;
781 // Constructors for engaged optionals.
782 template<typename... _Args,
783 enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
784 constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
785 : _M_payload(in_place,
786 std::forward<_Args>(__args)...) { }
788 template<typename _Up, typename... _Args,
789 enable_if_t<is_constructible_v<_Tp,
790 initializer_list<_Up>&,
791 _Args&&...>, bool> = false>
792 constexpr explicit _Optional_base(in_place_t,
793 initializer_list<_Up> __il,
795 : _M_payload(in_place,
796 __il, std::forward<_Args>(__args)...)
799 // Copy and move constructors.
800 constexpr _Optional_base(const _Optional_base& __other)
801 : _M_payload(__other._M_payload._M_engaged,
805 constexpr _Optional_base(_Optional_base&& __other) = default;
807 // Assignment operators.
808 _Optional_base& operator=(const _Optional_base&) = default;
809 _Optional_base& operator=(_Optional_base&&) = default;
813 constexpr bool _M_is_engaged() const noexcept
814 { return this->_M_payload._M_engaged; }
816 // The _M_get operations have _M_engaged as a precondition.
820 __glibcxx_assert(this->_M_is_engaged());
821 return this->_M_payload._M_payload;
825 _M_get() const noexcept
827 __glibcxx_assert(this->_M_is_engaged());
828 return this->_M_payload._M_payload;
832 _Optional_payload<_Tp> _M_payload;
835 template<typename _Tp>
836 class _Optional_base<_Tp, true, false>
837 : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
839 friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
842 // Constructors for disengaged optionals.
843 constexpr _Optional_base() = default;
845 // Constructors for engaged optionals.
846 template<typename... _Args,
847 enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
848 constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
849 : _M_payload(in_place,
850 std::forward<_Args>(__args)...) { }
852 template<typename _Up, typename... _Args,
853 enable_if_t<is_constructible_v<_Tp,
854 initializer_list<_Up>&,
855 _Args&&...>, bool> = false>
856 constexpr explicit _Optional_base(in_place_t,
857 initializer_list<_Up> __il,
859 : _M_payload(in_place,
860 __il, std::forward<_Args>(__args)...)
863 // Copy and move constructors.
864 constexpr _Optional_base(const _Optional_base& __other) = default;
866 constexpr _Optional_base(_Optional_base&& __other)
867 noexcept(is_nothrow_move_constructible_v<_Tp>)
868 : _M_payload(__other._M_payload._M_engaged,
869 std::move(__other._M_payload))
872 // Assignment operators.
873 _Optional_base& operator=(const _Optional_base&) = default;
874 _Optional_base& operator=(_Optional_base&&) = default;
878 constexpr bool _M_is_engaged() const noexcept
879 { return this->_M_payload._M_engaged; }
881 // The _M_get operations have _M_engaged as a precondition.
885 __glibcxx_assert(this->_M_is_engaged());
886 return this->_M_payload._M_payload;
890 _M_get() const noexcept
892 __glibcxx_assert(this->_M_is_engaged());
893 return this->_M_payload._M_payload;
897 _Optional_payload<_Tp> _M_payload;
900 template<typename _Tp>
901 class _Optional_base<_Tp, true, true>
902 : protected _Optional_base_impl<_Tp, _Optional_base<_Tp>>
904 friend class _Optional_base_impl<_Tp, _Optional_base<_Tp>>;
907 // Constructors for disengaged optionals.
908 constexpr _Optional_base() = default;
910 // Constructors for engaged optionals.
911 template<typename... _Args,
912 enable_if_t<is_constructible_v<_Tp, _Args&&...>, bool> = false>
913 constexpr explicit _Optional_base(in_place_t, _Args&&... __args)
914 : _M_payload(in_place,
915 std::forward<_Args>(__args)...) { }
917 template<typename _Up, typename... _Args,
918 enable_if_t<is_constructible_v<_Tp,
919 initializer_list<_Up>&,
920 _Args&&...>, bool> = false>
921 constexpr explicit _Optional_base(in_place_t,
922 initializer_list<_Up> __il,
924 : _M_payload(in_place,
925 __il, std::forward<_Args>(__args)...)
928 // Copy and move constructors.
929 constexpr _Optional_base(const _Optional_base& __other) = default;
930 constexpr _Optional_base(_Optional_base&& __other) = default;
932 // Assignment operators.
933 _Optional_base& operator=(const _Optional_base&) = default;
934 _Optional_base& operator=(_Optional_base&&) = default;
938 constexpr bool _M_is_engaged() const noexcept
939 { return this->_M_payload._M_engaged; }
941 // The _M_get operations have _M_engaged as a precondition.
945 __glibcxx_assert(this->_M_is_engaged());
946 return this->_M_payload._M_payload;
950 _M_get() const noexcept
952 __glibcxx_assert(this->_M_is_engaged());
953 return this->_M_payload._M_payload;
957 _Optional_payload<_Tp> _M_payload;
960 template<typename _Tp>
963 template<typename _Tp, typename _Up>
964 using __converts_from_optional =
965 __or_<is_constructible<_Tp, const optional<_Up>&>,
966 is_constructible<_Tp, optional<_Up>&>,
967 is_constructible<_Tp, const optional<_Up>&&>,
968 is_constructible<_Tp, optional<_Up>&&>,
969 is_convertible<const optional<_Up>&, _Tp>,
970 is_convertible<optional<_Up>&, _Tp>,
971 is_convertible<const optional<_Up>&&, _Tp>,
972 is_convertible<optional<_Up>&&, _Tp>>;
974 template<typename _Tp, typename _Up>
975 using __assigns_from_optional =
976 __or_<is_assignable<_Tp&, const optional<_Up>&>,
977 is_assignable<_Tp&, optional<_Up>&>,
978 is_assignable<_Tp&, const optional<_Up>&&>,
979 is_assignable<_Tp&, optional<_Up>&&>>;
982 * @brief Class template for optional values.
984 template<typename _Tp>
986 : private _Optional_base<_Tp>,
987 private _Enable_copy_move<
989 is_copy_constructible_v<_Tp>,
991 __and_v<is_copy_constructible<_Tp>, is_copy_assignable<_Tp>>,
993 is_move_constructible_v<_Tp>,
995 __and_v<is_move_constructible<_Tp>, is_move_assignable<_Tp>>,
999 static_assert(!is_same_v<remove_cv_t<_Tp>, nullopt_t>);
1000 static_assert(!is_same_v<remove_cv_t<_Tp>, in_place_t>);
1001 static_assert(!is_reference_v<_Tp>);
1004 using _Base = _Optional_base<_Tp>;
1007 template<typename _Up>
1008 using __not_self = __not_<is_same<optional, __remove_cvref_t<_Up>>>;
1009 template<typename _Up>
1010 using __not_tag = __not_<is_same<in_place_t, __remove_cvref_t<_Up>>>;
1011 template<typename... _Cond>
1012 using _Requires = enable_if_t<__and_v<_Cond...>, bool>;
1015 using value_type = _Tp;
1017 constexpr optional() = default;
1019 constexpr optional(nullopt_t) noexcept { }
1021 // Converting constructors for engaged optionals.
1022 template<typename _Up = _Tp,
1023 _Requires<__not_self<_Up>, __not_tag<_Up>,
1024 is_constructible<_Tp, _Up&&>,
1025 is_convertible<_Up&&, _Tp>> = true>
1028 : _Base(std::in_place, std::forward<_Up>(__t)) { }
1030 template<typename _Up = _Tp,
1031 _Requires<__not_self<_Up>, __not_tag<_Up>,
1032 is_constructible<_Tp, _Up&&>,
1033 __not_<is_convertible<_Up&&, _Tp>>> = false>
1036 : _Base(std::in_place, std::forward<_Up>(__t)) { }
1038 template<typename _Up,
1039 _Requires<__not_<is_same<_Tp, _Up>>,
1040 is_constructible<_Tp, const _Up&>,
1041 is_convertible<const _Up&, _Tp>,
1042 __not_<__converts_from_optional<_Tp, _Up>>> = true>
1044 optional(const optional<_Up>& __t)
1050 template<typename _Up,
1051 _Requires<__not_<is_same<_Tp, _Up>>,
1052 is_constructible<_Tp, const _Up&>,
1053 __not_<is_convertible<const _Up&, _Tp>>,
1054 __not_<__converts_from_optional<_Tp, _Up>>> = false>
1056 optional(const optional<_Up>& __t)
1062 template <typename _Up,
1063 _Requires<__not_<is_same<_Tp, _Up>>,
1064 is_constructible<_Tp, _Up&&>,
1065 is_convertible<_Up&&, _Tp>,
1066 __not_<__converts_from_optional<_Tp, _Up>>> = true>
1068 optional(optional<_Up>&& __t)
1071 emplace(std::move(*__t));
1074 template <typename _Up,
1075 _Requires<__not_<is_same<_Tp, _Up>>,
1076 is_constructible<_Tp, _Up&&>,
1077 __not_<is_convertible<_Up&&, _Tp>>,
1078 __not_<__converts_from_optional<_Tp, _Up>>> = false>
1080 optional(optional<_Up>&& __t)
1083 emplace(std::move(*__t));
1086 template<typename... _Args,
1087 _Requires<is_constructible<_Tp, _Args&&...>> = false>
1089 optional(in_place_t, _Args&&... __args)
1090 : _Base(std::in_place, std::forward<_Args>(__args)...) { }
1092 template<typename _Up, typename... _Args,
1093 _Requires<is_constructible<_Tp,
1094 initializer_list<_Up>&,
1095 _Args&&...>> = false>
1097 optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
1098 : _Base(std::in_place, __il, std::forward<_Args>(__args)...) { }
1100 // Assignment operators.
1102 operator=(nullopt_t) noexcept
1108 template<typename _Up = _Tp>
1109 enable_if_t<__and_v<__not_self<_Up>,
1110 __not_<__and_<is_scalar<_Tp>,
1111 is_same<_Tp, decay_t<_Up>>>>,
1112 is_constructible<_Tp, _Up>,
1113 is_assignable<_Tp&, _Up>>,
1115 operator=(_Up&& __u)
1117 if (this->_M_is_engaged())
1118 this->_M_get() = std::forward<_Up>(__u);
1120 this->_M_construct(std::forward<_Up>(__u));
1125 template<typename _Up>
1126 enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
1127 is_constructible<_Tp, const _Up&>,
1128 is_assignable<_Tp&, _Up>,
1129 __not_<__converts_from_optional<_Tp, _Up>>,
1130 __not_<__assigns_from_optional<_Tp, _Up>>>,
1132 operator=(const optional<_Up>& __u)
1136 if (this->_M_is_engaged())
1137 this->_M_get() = *__u;
1139 this->_M_construct(*__u);
1148 template<typename _Up>
1149 enable_if_t<__and_v<__not_<is_same<_Tp, _Up>>,
1150 is_constructible<_Tp, _Up>,
1151 is_assignable<_Tp&, _Up>,
1152 __not_<__converts_from_optional<_Tp, _Up>>,
1153 __not_<__assigns_from_optional<_Tp, _Up>>>,
1155 operator=(optional<_Up>&& __u)
1159 if (this->_M_is_engaged())
1160 this->_M_get() = std::move(*__u);
1162 this->_M_construct(std::move(*__u));
1172 template<typename... _Args>
1173 enable_if_t<is_constructible_v<_Tp, _Args&&...>, _Tp&>
1174 emplace(_Args&&... __args)
1177 this->_M_construct(std::forward<_Args>(__args)...);
1178 return this->_M_get();
1181 template<typename _Up, typename... _Args>
1182 enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&,
1184 emplace(initializer_list<_Up> __il, _Args&&... __args)
1187 this->_M_construct(__il, std::forward<_Args>(__args)...);
1188 return this->_M_get();
1191 // Destructor is implicit, implemented in _Optional_base.
1195 swap(optional& __other)
1196 noexcept(is_nothrow_move_constructible_v<_Tp>
1197 && is_nothrow_swappable_v<_Tp>)
1201 if (this->_M_is_engaged() && __other._M_is_engaged())
1202 swap(this->_M_get(), __other._M_get());
1203 else if (this->_M_is_engaged())
1205 __other._M_construct(std::move(this->_M_get()));
1206 this->_M_destruct();
1208 else if (__other._M_is_engaged())
1210 this->_M_construct(std::move(__other._M_get()));
1211 __other._M_destruct();
1216 constexpr const _Tp*
1218 { return std::__addressof(this->_M_get()); }
1222 { return std::__addressof(this->_M_get()); }
1224 constexpr const _Tp&
1226 { return this->_M_get(); }
1230 { return this->_M_get(); }
1234 { return std::move(this->_M_get()); }
1236 constexpr const _Tp&&
1238 { return std::move(this->_M_get()); }
1240 constexpr explicit operator bool() const noexcept
1241 { return this->_M_is_engaged(); }
1243 constexpr bool has_value() const noexcept
1244 { return this->_M_is_engaged(); }
1246 constexpr const _Tp&
1249 return this->_M_is_engaged()
1251 : (__throw_bad_optional_access(),
1258 return this->_M_is_engaged()
1260 : (__throw_bad_optional_access(),
1267 return this->_M_is_engaged()
1268 ? std::move(this->_M_get())
1269 : (__throw_bad_optional_access(),
1270 std::move(this->_M_get()));
1273 constexpr const _Tp&&
1276 return this->_M_is_engaged()
1277 ? std::move(this->_M_get())
1278 : (__throw_bad_optional_access(),
1279 std::move(this->_M_get()));
1282 template<typename _Up>
1284 value_or(_Up&& __u) const&
1286 static_assert(is_copy_constructible_v<_Tp>);
1287 static_assert(is_convertible_v<_Up&&, _Tp>);
1289 return this->_M_is_engaged()
1291 : static_cast<_Tp>(std::forward<_Up>(__u));
1294 template<typename _Up>
1296 value_or(_Up&& __u) &&
1298 static_assert(is_move_constructible_v<_Tp>);
1299 static_assert(is_convertible_v<_Up&&, _Tp>);
1301 return this->_M_is_engaged()
1302 ? std::move(this->_M_get())
1303 : static_cast<_Tp>(std::forward<_Up>(__u));
1306 void reset() noexcept { this->_M_reset(); }
1309 template<typename _Tp>
1310 using __optional_relop_t =
1311 enable_if_t<is_convertible<_Tp, bool>::value, bool>;
1313 // Comparisons between optional values.
1314 template<typename _Tp, typename _Up>
1316 operator==(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1317 -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
1319 return static_cast<bool>(__lhs) == static_cast<bool>(__rhs)
1320 && (!__lhs || *__lhs == *__rhs);
1323 template<typename _Tp, typename _Up>
1325 operator!=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1326 -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
1328 return static_cast<bool>(__lhs) != static_cast<bool>(__rhs)
1329 || (static_cast<bool>(__lhs) && *__lhs != *__rhs);
1332 template<typename _Tp, typename _Up>
1334 operator<(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1335 -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
1337 return static_cast<bool>(__rhs) && (!__lhs || *__lhs < *__rhs);
1340 template<typename _Tp, typename _Up>
1342 operator>(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1343 -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
1345 return static_cast<bool>(__lhs) && (!__rhs || *__lhs > *__rhs);
1348 template<typename _Tp, typename _Up>
1350 operator<=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1351 -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
1353 return !__lhs || (static_cast<bool>(__rhs) && *__lhs <= *__rhs);
1356 template<typename _Tp, typename _Up>
1358 operator>=(const optional<_Tp>& __lhs, const optional<_Up>& __rhs)
1359 -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
1361 return !__rhs || (static_cast<bool>(__lhs) && *__lhs >= *__rhs);
1364 // Comparisons with nullopt.
1365 template<typename _Tp>
1367 operator==(const optional<_Tp>& __lhs, nullopt_t) noexcept
1370 template<typename _Tp>
1372 operator==(nullopt_t, const optional<_Tp>& __rhs) noexcept
1375 template<typename _Tp>
1377 operator!=(const optional<_Tp>& __lhs, nullopt_t) noexcept
1378 { return static_cast<bool>(__lhs); }
1380 template<typename _Tp>
1382 operator!=(nullopt_t, const optional<_Tp>& __rhs) noexcept
1383 { return static_cast<bool>(__rhs); }
1385 template<typename _Tp>
1387 operator<(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
1390 template<typename _Tp>
1392 operator<(nullopt_t, const optional<_Tp>& __rhs) noexcept
1393 { return static_cast<bool>(__rhs); }
1395 template<typename _Tp>
1397 operator>(const optional<_Tp>& __lhs, nullopt_t) noexcept
1398 { return static_cast<bool>(__lhs); }
1400 template<typename _Tp>
1402 operator>(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
1405 template<typename _Tp>
1407 operator<=(const optional<_Tp>& __lhs, nullopt_t) noexcept
1410 template<typename _Tp>
1412 operator<=(nullopt_t, const optional<_Tp>& /* __rhs */) noexcept
1415 template<typename _Tp>
1417 operator>=(const optional<_Tp>& /* __lhs */, nullopt_t) noexcept
1420 template<typename _Tp>
1422 operator>=(nullopt_t, const optional<_Tp>& __rhs) noexcept
1425 // Comparisons with value type.
1426 template<typename _Tp, typename _Up>
1428 operator==(const optional<_Tp>& __lhs, const _Up& __rhs)
1429 -> __optional_relop_t<decltype(declval<_Tp>() == declval<_Up>())>
1430 { return __lhs && *__lhs == __rhs; }
1432 template<typename _Tp, typename _Up>
1434 operator==(const _Up& __lhs, const optional<_Tp>& __rhs)
1435 -> __optional_relop_t<decltype(declval<_Up>() == declval<_Tp>())>
1436 { return __rhs && __lhs == *__rhs; }
1438 template<typename _Tp, typename _Up>
1440 operator!=(const optional<_Tp>& __lhs, const _Up& __rhs)
1441 -> __optional_relop_t<decltype(declval<_Tp>() != declval<_Up>())>
1442 { return !__lhs || *__lhs != __rhs; }
1444 template<typename _Tp, typename _Up>
1446 operator!=(const _Up& __lhs, const optional<_Tp>& __rhs)
1447 -> __optional_relop_t<decltype(declval<_Up>() != declval<_Tp>())>
1448 { return !__rhs || __lhs != *__rhs; }
1450 template<typename _Tp, typename _Up>
1452 operator<(const optional<_Tp>& __lhs, const _Up& __rhs)
1453 -> __optional_relop_t<decltype(declval<_Tp>() < declval<_Up>())>
1454 { return !__lhs || *__lhs < __rhs; }
1456 template<typename _Tp, typename _Up>
1458 operator<(const _Up& __lhs, const optional<_Tp>& __rhs)
1459 -> __optional_relop_t<decltype(declval<_Up>() < declval<_Tp>())>
1460 { return __rhs && __lhs < *__rhs; }
1462 template<typename _Tp, typename _Up>
1464 operator>(const optional<_Tp>& __lhs, const _Up& __rhs)
1465 -> __optional_relop_t<decltype(declval<_Tp>() > declval<_Up>())>
1466 { return __lhs && *__lhs > __rhs; }
1468 template<typename _Tp, typename _Up>
1470 operator>(const _Up& __lhs, const optional<_Tp>& __rhs)
1471 -> __optional_relop_t<decltype(declval<_Up>() > declval<_Tp>())>
1472 { return !__rhs || __lhs > *__rhs; }
1474 template<typename _Tp, typename _Up>
1476 operator<=(const optional<_Tp>& __lhs, const _Up& __rhs)
1477 -> __optional_relop_t<decltype(declval<_Tp>() <= declval<_Up>())>
1478 { return !__lhs || *__lhs <= __rhs; }
1480 template<typename _Tp, typename _Up>
1482 operator<=(const _Up& __lhs, const optional<_Tp>& __rhs)
1483 -> __optional_relop_t<decltype(declval<_Up>() <= declval<_Tp>())>
1484 { return __rhs && __lhs <= *__rhs; }
1486 template<typename _Tp, typename _Up>
1488 operator>=(const optional<_Tp>& __lhs, const _Up& __rhs)
1489 -> __optional_relop_t<decltype(declval<_Tp>() >= declval<_Up>())>
1490 { return __lhs && *__lhs >= __rhs; }
1492 template<typename _Tp, typename _Up>
1494 operator>=(const _Up& __lhs, const optional<_Tp>& __rhs)
1495 -> __optional_relop_t<decltype(declval<_Up>() >= declval<_Tp>())>
1496 { return !__rhs || __lhs >= *__rhs; }
1498 // Swap and creation functions.
1500 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1501 // 2748. swappable traits for optionals
1502 template<typename _Tp>
1503 inline enable_if_t<is_move_constructible_v<_Tp> && is_swappable_v<_Tp>>
1504 swap(optional<_Tp>& __lhs, optional<_Tp>& __rhs)
1505 noexcept(noexcept(__lhs.swap(__rhs)))
1506 { __lhs.swap(__rhs); }
1508 template<typename _Tp>
1509 enable_if_t<!(is_move_constructible_v<_Tp> && is_swappable_v<_Tp>)>
1510 swap(optional<_Tp>&, optional<_Tp>&) = delete;
1512 template<typename _Tp>
1513 constexpr optional<decay_t<_Tp>>
1514 make_optional(_Tp&& __t)
1515 { return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }
1517 template<typename _Tp, typename ..._Args>
1518 constexpr optional<_Tp>
1519 make_optional(_Args&&... __args)
1520 { return optional<_Tp> { in_place, std::forward<_Args>(__args)... }; }
1522 template<typename _Tp, typename _Up, typename ..._Args>
1523 constexpr optional<_Tp>
1524 make_optional(initializer_list<_Up> __il, _Args&&... __args)
1525 { return optional<_Tp> { in_place, __il, std::forward<_Args>(__args)... }; }
1529 template<typename _Tp, typename _Up = remove_const_t<_Tp>,
1530 bool = __poison_hash<_Up>::__enable_hash_call>
1531 struct __optional_hash_call_base
1534 operator()(const optional<_Tp>& __t) const
1535 noexcept(noexcept(hash<_Up>{}(*__t)))
1537 // We pick an arbitrary hash for disengaged optionals which hopefully
1538 // usual values of _Tp won't typically hash to.
1539 constexpr size_t __magic_disengaged_hash = static_cast<size_t>(-3333);
1540 return __t ? hash<_Up>{}(*__t) : __magic_disengaged_hash;
1544 template<typename _Tp, typename _Up>
1545 struct __optional_hash_call_base<_Tp, _Up, false> {};
1547 template<typename _Tp>
1548 struct hash<optional<_Tp>>
1549 : private __poison_hash<remove_const_t<_Tp>>,
1550 public __optional_hash_call_base<_Tp>
1552 using result_type [[__deprecated__]] = size_t;
1553 using argument_type [[__deprecated__]] = optional<_Tp>;
1556 template<typename _Tp>
1557 struct __is_fast_hash<hash<optional<_Tp>>> : __is_fast_hash<hash<_Tp>>
1562 #if __cpp_deduction_guides >= 201606
1563 template <typename _Tp> optional(_Tp) -> optional<_Tp>;
1566 _GLIBCXX_END_NAMESPACE_VERSION
1571 #endif // _GLIBCXX_OPTIONAL