1// -*- C++ -*-
2//===-------------------------- optional ----------------------------------===//
3//
4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5// See https://llvm.org/LICENSE.txt for license information.
6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7//
8//===----------------------------------------------------------------------===//
9
10#ifndef _LIBCPP_OPTIONAL
11#define _LIBCPP_OPTIONAL
12
13/*
14 optional synopsis
15
16// C++1z
17
18namespace std {
19 // 23.6.3, optional for object types
20 template <class T> class optional;
21
22 // 23.6.4, no-value state indicator
23 struct nullopt_t{see below };
24 inline constexpr nullopt_t nullopt(unspecified );
25
26 // 23.6.5, class bad_optional_access
27 class bad_optional_access;
28
29 // 23.6.6, relational operators
30 template <class T, class U>
31 constexpr bool operator==(const optional<T>&, const optional<U>&);
32 template <class T, class U>
33 constexpr bool operator!=(const optional<T>&, const optional<U>&);
34 template <class T, class U>
35 constexpr bool operator<(const optional<T>&, const optional<U>&);
36 template <class T, class U>
37 constexpr bool operator>(const optional<T>&, const optional<U>&);
38 template <class T, class U>
39 constexpr bool operator<=(const optional<T>&, const optional<U>&);
40 template <class T, class U>
41 constexpr bool operator>=(const optional<T>&, const optional<U>&);
42
43 // 23.6.7 comparison with nullopt
44 template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
45 template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
46 template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
47 template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
48 template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
49 template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
50 template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
51 template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
52 template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
53 template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
54 template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
55 template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;
56
57 // 23.6.8, comparison with T
58 template <class T, class U> constexpr bool operator==(const optional<T>&, const U&);
59 template <class T, class U> constexpr bool operator==(const T&, const optional<U>&);
60 template <class T, class U> constexpr bool operator!=(const optional<T>&, const U&);
61 template <class T, class U> constexpr bool operator!=(const T&, const optional<U>&);
62 template <class T, class U> constexpr bool operator<(const optional<T>&, const U&);
63 template <class T, class U> constexpr bool operator<(const T&, const optional<U>&);
64 template <class T, class U> constexpr bool operator<=(const optional<T>&, const U&);
65 template <class T, class U> constexpr bool operator<=(const T&, const optional<U>&);
66 template <class T, class U> constexpr bool operator>(const optional<T>&, const U&);
67 template <class T, class U> constexpr bool operator>(const T&, const optional<U>&);
68 template <class T, class U> constexpr bool operator>=(const optional<T>&, const U&);
69 template <class T, class U> constexpr bool operator>=(const T&, const optional<U>&);
70
71 // 23.6.9, specialized algorithms
72 template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below );
73 template <class T> constexpr optional<see below > make_optional(T&&);
74 template <class T, class... Args>
75 constexpr optional<T> make_optional(Args&&... args);
76 template <class T, class U, class... Args>
77 constexpr optional<T> make_optional(initializer_list<U> il, Args&&... args);
78
79 // 23.6.10, hash support
80 template <class T> struct hash;
81 template <class T> struct hash<optional<T>>;
82
83 template <class T> class optional {
84 public:
85 using value_type = T;
86
87 // 23.6.3.1, constructors
88 constexpr optional() noexcept;
89 constexpr optional(nullopt_t) noexcept;
90 optional(const optional &);
91 optional(optional &&) noexcept(see below);
92 template <class... Args> constexpr explicit optional(in_place_t, Args &&...);
93 template <class U, class... Args>
94 constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...);
95 template <class U = T>
96 constexpr EXPLICIT optional(U &&);
97 template <class U>
98 constexpr EXPLICIT optional(const optional<U> &);
99 template <class U>
100 constexpr EXPLICIT optional(optional<U> &&);
101
102 // 23.6.3.2, destructor
103 ~optional();
104
105 // 23.6.3.3, assignment
106 optional &operator=(nullopt_t) noexcept;
107 optional &operator=(const optional &); // constexpr in C++20
108 optional &operator=(optional &&) noexcept(see below); // constexpr in C++20
109 template <class U = T> optional &operator=(U &&);
110 template <class U> optional &operator=(const optional<U> &);
111 template <class U> optional &operator=(optional<U> &&);
112 template <class... Args> T& emplace(Args &&...);
113 template <class U, class... Args>
114 T& emplace(initializer_list<U>, Args &&...);
115
116 // 23.6.3.4, swap
117 void swap(optional &) noexcept(see below );
118
119 // 23.6.3.5, observers
120 constexpr T const *operator->() const;
121 constexpr T *operator->();
122 constexpr T const &operator*() const &;
123 constexpr T &operator*() &;
124 constexpr T &&operator*() &&;
125 constexpr const T &&operator*() const &&;
126 constexpr explicit operator bool() const noexcept;
127 constexpr bool has_value() const noexcept;
128 constexpr T const &value() const &;
129 constexpr T &value() &;
130 constexpr T &&value() &&;
131 constexpr const T &&value() const &&;
132 template <class U> constexpr T value_or(U &&) const &;
133 template <class U> constexpr T value_or(U &&) &&;
134
135 // 23.6.3.6, modifiers
136 void reset() noexcept;
137
138 private:
139 T *val; // exposition only
140 };
141
142template<class T>
143 optional(T) -> optional<T>;
144
145} // namespace std
146
147*/
148
149#include <__config>
150#include <__debug>
151#include <__functional_base>
152#include <functional>
153#include <initializer_list>
154#include <new>
155#include <stdexcept>
156#include <type_traits>
157#include <utility>
158#include <version>
159
160#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
161#pragma GCC system_header
162#endif
163
164_LIBCPP_PUSH_MACROS
165#include <__undef_macros>
166
167
168namespace std // purposefully not using versioning namespace
169{
170
171class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS bad_optional_access
172 : public exception
173{
174public:
175 // Get the key function ~bad_optional_access() into the dylib
176 virtual ~bad_optional_access() _NOEXCEPT;
177 virtual const char* what() const _NOEXCEPT;
178};
179
180} // std
181
182#if _LIBCPP_STD_VER > 14
183
184_LIBCPP_BEGIN_NAMESPACE_STD
185
186_LIBCPP_NORETURN
187inline _LIBCPP_INLINE_VISIBILITY
188_LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
189void __throw_bad_optional_access() {
190#ifndef _LIBCPP_NO_EXCEPTIONS
191 throw bad_optional_access();
192#else
193 _VSTD::abort();
194#endif
195}
196
197struct nullopt_t
198{
199 struct __secret_tag { _LIBCPP_INLINE_VISIBILITY explicit __secret_tag() = default; };
200 _LIBCPP_INLINE_VISIBILITY constexpr explicit nullopt_t(__secret_tag, __secret_tag) noexcept {}
201};
202
203_LIBCPP_INLINE_VAR constexpr nullopt_t nullopt{nullopt_t::__secret_tag{}, nullopt_t::__secret_tag{}};
204
205template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
206struct __optional_destruct_base;
207
208template <class _Tp>
209struct __optional_destruct_base<_Tp, false>
210{
211 typedef _Tp value_type;
212 static_assert(is_object_v<value_type>,
213 "instantiation of optional with a non-object type is undefined behavior");
214 union
215 {
216 char __null_state_;
217 value_type __val_;
218 };
219 bool __engaged_;
220
221 _LIBCPP_INLINE_VISIBILITY
222 ~__optional_destruct_base()
223 {
224 if (__engaged_)
225 __val_.~value_type();
226 }
227
228 _LIBCPP_INLINE_VISIBILITY
229 constexpr __optional_destruct_base() noexcept
230 : __null_state_(),
231 __engaged_(false) {}
232
233 template <class... _Args>
234 _LIBCPP_INLINE_VISIBILITY
235 constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
236 : __val_(_VSTD::forward<_Args>(__args)...),
237 __engaged_(true) {}
238
239 _LIBCPP_INLINE_VISIBILITY
240 void reset() noexcept
241 {
242 if (__engaged_)
243 {
244 __val_.~value_type();
245 __engaged_ = false;
246 }
247 }
248};
249
250template <class _Tp>
251struct __optional_destruct_base<_Tp, true>
252{
253 typedef _Tp value_type;
254 static_assert(is_object_v<value_type>,
255 "instantiation of optional with a non-object type is undefined behavior");
256 union
257 {
258 char __null_state_;
259 value_type __val_;
260 };
261 bool __engaged_;
262
263 _LIBCPP_INLINE_VISIBILITY
264 constexpr __optional_destruct_base() noexcept
265 : __null_state_(),
266 __engaged_(false) {}
267
268 template <class... _Args>
269 _LIBCPP_INLINE_VISIBILITY
270 constexpr explicit __optional_destruct_base(in_place_t, _Args&&... __args)
271 : __val_(_VSTD::forward<_Args>(__args)...),
272 __engaged_(true) {}
273
274 _LIBCPP_INLINE_VISIBILITY
275 void reset() noexcept
276 {
277 if (__engaged_)
278 {
279 __engaged_ = false;
280 }
281 }
282};
283
284template <class _Tp, bool = is_reference<_Tp>::value>
285struct __optional_storage_base : __optional_destruct_base<_Tp>
286{
287 using __base = __optional_destruct_base<_Tp>;
288 using value_type = _Tp;
289 using __base::__base;
290
291 _LIBCPP_INLINE_VISIBILITY
292 constexpr bool has_value() const noexcept
293 {
294 return this->__engaged_;
295 }
296
297 _LIBCPP_INLINE_VISIBILITY
298 constexpr value_type& __get() & noexcept
299 {
300 return this->__val_;
301 }
302 _LIBCPP_INLINE_VISIBILITY
303 constexpr const value_type& __get() const& noexcept
304 {
305 return this->__val_;
306 }
307 _LIBCPP_INLINE_VISIBILITY
308 constexpr value_type&& __get() && noexcept
309 {
310 return _VSTD::move(this->__val_);
311 }
312 _LIBCPP_INLINE_VISIBILITY
313 constexpr const value_type&& __get() const&& noexcept
314 {
315 return _VSTD::move(this->__val_);
316 }
317
318 template <class... _Args>
319 _LIBCPP_INLINE_VISIBILITY
320 void __construct(_Args&&... __args)
321 {
322 _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
323 ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
324 this->__engaged_ = true;
325 }
326
327 template <class _That>
328 _LIBCPP_INLINE_VISIBILITY
329 void __construct_from(_That&& __opt)
330 {
331 if (__opt.has_value())
332 __construct(_VSTD::forward<_That>(__opt).__get());
333 }
334
335 template <class _That>
336 _LIBCPP_INLINE_VISIBILITY
337 void __assign_from(_That&& __opt)
338 {
339 if (this->__engaged_ == __opt.has_value())
340 {
341 if (this->__engaged_)
342 this->__val_ = _VSTD::forward<_That>(__opt).__get();
343 }
344 else
345 {
346 if (this->__engaged_)
347 this->reset();
348 else
349 __construct(_VSTD::forward<_That>(__opt).__get());
350 }
351 }
352};
353
354// optional<T&> is currently required ill-formed, however it may to be in the
355// future. For this reason it has already been implemented to ensure we can
356// make the change in an ABI compatible manner.
357template <class _Tp>
358struct __optional_storage_base<_Tp, true>
359{
360 using value_type = _Tp;
361 using __raw_type = remove_reference_t<_Tp>;
362 __raw_type* __value_;
363
364 template <class _Up>
365 static constexpr bool __can_bind_reference() {
366 using _RawUp = typename remove_reference<_Up>::type;
367 using _UpPtr = _RawUp*;
368 using _RawTp = typename remove_reference<_Tp>::type;
369 using _TpPtr = _RawTp*;
370 using _CheckLValueArg = integral_constant<bool,
371 (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value)
372 || is_same<_RawUp, reference_wrapper<_RawTp>>::value
373 || is_same<_RawUp, reference_wrapper<typename remove_const<_RawTp>::type>>::value
374 >;
375 return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value)
376 || (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value &&
377 is_convertible<_UpPtr, _TpPtr>::value);
378 }
379
380 _LIBCPP_INLINE_VISIBILITY
381 constexpr __optional_storage_base() noexcept
382 : __value_(nullptr) {}
383
384 template <class _UArg>
385 _LIBCPP_INLINE_VISIBILITY
386 constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
387 : __value_(_VSTD::addressof(__uarg))
388 {
389 static_assert(__can_bind_reference<_UArg>(),
390 "Attempted to construct a reference element in tuple from a "
391 "possible temporary");
392 }
393
394 _LIBCPP_INLINE_VISIBILITY
395 void reset() noexcept { __value_ = nullptr; }
396
397 _LIBCPP_INLINE_VISIBILITY
398 constexpr bool has_value() const noexcept
399 { return __value_ != nullptr; }
400
401 _LIBCPP_INLINE_VISIBILITY
402 constexpr value_type& __get() const& noexcept
403 { return *__value_; }
404
405 _LIBCPP_INLINE_VISIBILITY
406 constexpr value_type&& __get() const&& noexcept
407 { return _VSTD::forward<value_type>(*__value_); }
408
409 template <class _UArg>
410 _LIBCPP_INLINE_VISIBILITY
411 void __construct(_UArg&& __val)
412 {
413 _LIBCPP_ASSERT(!has_value(), "__construct called for engaged __optional_storage");
414 static_assert(__can_bind_reference<_UArg>(),
415 "Attempted to construct a reference element in tuple from a "
416 "possible temporary");
417 __value_ = _VSTD::addressof(__val);
418 }
419
420 template <class _That>
421 _LIBCPP_INLINE_VISIBILITY
422 void __construct_from(_That&& __opt)
423 {
424 if (__opt.has_value())
425 __construct(_VSTD::forward<_That>(__opt).__get());
426 }
427
428 template <class _That>
429 _LIBCPP_INLINE_VISIBILITY
430 void __assign_from(_That&& __opt)
431 {
432 if (has_value() == __opt.has_value())
433 {
434 if (has_value())
435 *__value_ = _VSTD::forward<_That>(__opt).__get();
436 }
437 else
438 {
439 if (has_value())
440 reset();
441 else
442 __construct(_VSTD::forward<_That>(__opt).__get());
443 }
444 }
445};
446
447template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value>
448struct __optional_copy_base : __optional_storage_base<_Tp>
449{
450 using __optional_storage_base<_Tp>::__optional_storage_base;
451};
452
453template <class _Tp>
454struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp>
455{
456 using __optional_storage_base<_Tp>::__optional_storage_base;
457
458 _LIBCPP_INLINE_VISIBILITY
459 __optional_copy_base() = default;
460
461 _LIBCPP_INLINE_VISIBILITY
462 __optional_copy_base(const __optional_copy_base& __opt)
463 {
464 this->__construct_from(__opt);
465 }
466
467 _LIBCPP_INLINE_VISIBILITY
468 __optional_copy_base(__optional_copy_base&&) = default;
469 _LIBCPP_INLINE_VISIBILITY
470 __optional_copy_base& operator=(const __optional_copy_base&) = default;
471 _LIBCPP_INLINE_VISIBILITY
472 __optional_copy_base& operator=(__optional_copy_base&&) = default;
473};
474
475template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value>
476struct __optional_move_base : __optional_copy_base<_Tp>
477{
478 using __optional_copy_base<_Tp>::__optional_copy_base;
479};
480
481template <class _Tp>
482struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp>
483{
484 using value_type = _Tp;
485 using __optional_copy_base<_Tp>::__optional_copy_base;
486
487 _LIBCPP_INLINE_VISIBILITY
488 __optional_move_base() = default;
489 _LIBCPP_INLINE_VISIBILITY
490 __optional_move_base(const __optional_move_base&) = default;
491
492 _LIBCPP_INLINE_VISIBILITY
493 __optional_move_base(__optional_move_base&& __opt)
494 noexcept(is_nothrow_move_constructible_v<value_type>)
495 {
496 this->__construct_from(_VSTD::move(__opt));
497 }
498
499 _LIBCPP_INLINE_VISIBILITY
500 __optional_move_base& operator=(const __optional_move_base&) = default;
501 _LIBCPP_INLINE_VISIBILITY
502 __optional_move_base& operator=(__optional_move_base&&) = default;
503};
504
505template <class _Tp, bool =
506 is_trivially_destructible<_Tp>::value &&
507 is_trivially_copy_constructible<_Tp>::value &&
508 is_trivially_copy_assignable<_Tp>::value>
509struct __optional_copy_assign_base : __optional_move_base<_Tp>
510{
511 using __optional_move_base<_Tp>::__optional_move_base;
512};
513
514template <class _Tp>
515struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp>
516{
517 using __optional_move_base<_Tp>::__optional_move_base;
518
519 _LIBCPP_INLINE_VISIBILITY
520 __optional_copy_assign_base() = default;
521 _LIBCPP_INLINE_VISIBILITY
522 __optional_copy_assign_base(const __optional_copy_assign_base&) = default;
523 _LIBCPP_INLINE_VISIBILITY
524 __optional_copy_assign_base(__optional_copy_assign_base&&) = default;
525
526 _LIBCPP_INLINE_VISIBILITY
527 __optional_copy_assign_base& operator=(const __optional_copy_assign_base& __opt)
528 {
529 this->__assign_from(__opt);
530 return *this;
531 }
532
533 _LIBCPP_INLINE_VISIBILITY
534 __optional_copy_assign_base& operator=(__optional_copy_assign_base&&) = default;
535};
536
537template <class _Tp, bool =
538 is_trivially_destructible<_Tp>::value &&
539 is_trivially_move_constructible<_Tp>::value &&
540 is_trivially_move_assignable<_Tp>::value>
541struct __optional_move_assign_base : __optional_copy_assign_base<_Tp>
542{
543 using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
544};
545
546template <class _Tp>
547struct __optional_move_assign_base<_Tp, false> : __optional_copy_assign_base<_Tp>
548{
549 using value_type = _Tp;
550 using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
551
552 _LIBCPP_INLINE_VISIBILITY
553 __optional_move_assign_base() = default;
554 _LIBCPP_INLINE_VISIBILITY
555 __optional_move_assign_base(const __optional_move_assign_base& __opt) = default;
556 _LIBCPP_INLINE_VISIBILITY
557 __optional_move_assign_base(__optional_move_assign_base&&) = default;
558 _LIBCPP_INLINE_VISIBILITY
559 __optional_move_assign_base& operator=(const __optional_move_assign_base&) = default;
560
561 _LIBCPP_INLINE_VISIBILITY
562 __optional_move_assign_base& operator=(__optional_move_assign_base&& __opt)
563 noexcept(is_nothrow_move_assignable_v<value_type> &&
564 is_nothrow_move_constructible_v<value_type>)
565 {
566 this->__assign_from(_VSTD::move(__opt));
567 return *this;
568 }
569};
570
571template <class _Tp>
572using __optional_sfinae_ctor_base_t = __sfinae_ctor_base<
573 is_copy_constructible<_Tp>::value,
574 is_move_constructible<_Tp>::value
575>;
576
577template <class _Tp>
578using __optional_sfinae_assign_base_t = __sfinae_assign_base<
579 (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
580 (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value)
581>;
582
583template <class _Tp>
584class optional
585 : private __optional_move_assign_base<_Tp>
586 , private __optional_sfinae_ctor_base_t<_Tp>
587 , private __optional_sfinae_assign_base_t<_Tp>
588{
589 using __base = __optional_move_assign_base<_Tp>;
590public:
591 using value_type = _Tp;
592
593private:
594 // Disable the reference extension using this static assert.
595 static_assert(!is_same_v<__uncvref_t<value_type>, in_place_t>,
596 "instantiation of optional with in_place_t is ill-formed");
597 static_assert(!is_same_v<__uncvref_t<value_type>, nullopt_t>,
598 "instantiation of optional with nullopt_t is ill-formed");
599 static_assert(!is_reference_v<value_type>,
600 "instantiation of optional with a reference type is ill-formed");
601 static_assert(is_destructible_v<value_type>,
602 "instantiation of optional with a non-destructible type is ill-formed");
603 static_assert(!is_array_v<value_type>,
604 "instantiation of optional with an array type is ill-formed");
605
606 // LWG2756: conditionally explicit conversion from _Up
607 struct _CheckOptionalArgsConstructor {
608 template <class _Up>
609 static constexpr bool __enable_implicit() {
610 return is_constructible_v<_Tp, _Up&&> &&
611 is_convertible_v<_Up&&, _Tp>;
612 }
613
614 template <class _Up>
615 static constexpr bool __enable_explicit() {
616 return is_constructible_v<_Tp, _Up&&> &&
617 !is_convertible_v<_Up&&, _Tp>;
618 }
619 };
620 template <class _Up>
621 using _CheckOptionalArgsCtor = _If<
622 _IsNotSame<__uncvref_t<_Up>, in_place_t>::value &&
623 _IsNotSame<__uncvref_t<_Up>, optional>::value,
624 _CheckOptionalArgsConstructor,
625 __check_tuple_constructor_fail
626 >;
627 template <class _QualUp>
628 struct _CheckOptionalLikeConstructor {
629 template <class _Up, class _Opt = optional<_Up>>
630 using __check_constructible_from_opt = _Or<
631 is_constructible<_Tp, _Opt&>,
632 is_constructible<_Tp, _Opt const&>,
633 is_constructible<_Tp, _Opt&&>,
634 is_constructible<_Tp, _Opt const&&>,
635 is_convertible<_Opt&, _Tp>,
636 is_convertible<_Opt const&, _Tp>,
637 is_convertible<_Opt&&, _Tp>,
638 is_convertible<_Opt const&&, _Tp>
639 >;
640 template <class _Up, class _Opt = optional<_Up>>
641 using __check_assignable_from_opt = _Or<
642 is_assignable<_Tp&, _Opt&>,
643 is_assignable<_Tp&, _Opt const&>,
644 is_assignable<_Tp&, _Opt&&>,
645 is_assignable<_Tp&, _Opt const&&>
646 >;
647 template <class _Up, class _QUp = _QualUp>
648 static constexpr bool __enable_implicit() {
649 return is_convertible<_QUp, _Tp>::value &&
650 !__check_constructible_from_opt<_Up>::value;
651 }
652 template <class _Up, class _QUp = _QualUp>
653 static constexpr bool __enable_explicit() {
654 return !is_convertible<_QUp, _Tp>::value &&
655 !__check_constructible_from_opt<_Up>::value;
656 }
657 template <class _Up, class _QUp = _QualUp>
658 static constexpr bool __enable_assign() {
659 // Construction and assignability of _Qup to _Tp has already been
660 // checked.
661 return !__check_constructible_from_opt<_Up>::value &&
662 !__check_assignable_from_opt<_Up>::value;
663 }
664 };
665
666 template <class _Up, class _QualUp>
667 using _CheckOptionalLikeCtor = _If<
668 _And<
669 _IsNotSame<_Up, _Tp>,
670 is_constructible<_Tp, _QualUp>
671 >::value,
672 _CheckOptionalLikeConstructor<_QualUp>,
673 __check_tuple_constructor_fail
674 >;
675 template <class _Up, class _QualUp>
676 using _CheckOptionalLikeAssign = _If<
677 _And<
678 _IsNotSame<_Up, _Tp>,
679 is_constructible<_Tp, _QualUp>,
680 is_assignable<_Tp&, _QualUp>
681 >::value,
682 _CheckOptionalLikeConstructor<_QualUp>,
683 __check_tuple_constructor_fail
684 >;
685public:
686
687 _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
688 _LIBCPP_INLINE_VISIBILITY constexpr optional(const optional&) = default;
689 _LIBCPP_INLINE_VISIBILITY constexpr optional(optional&&) = default;
690 _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
691
692 template <class _InPlaceT, class... _Args, class = _EnableIf<
693 _And<
694 _IsSame<_InPlaceT, in_place_t>,
695 is_constructible<value_type, _Args...>
696 >::value
697 >
698 >
699 _LIBCPP_INLINE_VISIBILITY
700 constexpr explicit optional(_InPlaceT, _Args&&... __args)
701 : __base(in_place, _VSTD::forward<_Args>(__args)...) {}
702
703 template <class _Up, class... _Args, class = _EnableIf<
704 is_constructible_v<value_type, initializer_list<_Up>&, _Args...>>
705 >
706 _LIBCPP_INLINE_VISIBILITY
707 constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
708 : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}
709
710 template <class _Up = value_type, _EnableIf<
711 _CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>()
712 , int> = 0>
713 _LIBCPP_INLINE_VISIBILITY
714 constexpr optional(_Up&& __v)
715 : __base(in_place, _VSTD::forward<_Up>(__v)) {}
716
717 template <class _Up, _EnableIf<
718 _CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>()
719 , int> = 0>
720 _LIBCPP_INLINE_VISIBILITY
721 constexpr explicit optional(_Up&& __v)
722 : __base(in_place, _VSTD::forward<_Up>(__v)) {}
723
724 // LWG2756: conditionally explicit conversion from const optional<_Up>&
725 template <class _Up, _EnableIf<
726 _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>()
727 , int> = 0>
728 _LIBCPP_INLINE_VISIBILITY
729 optional(const optional<_Up>& __v)
730 {
731 this->__construct_from(__v);
732 }
733 template <class _Up, _EnableIf<
734 _CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>()
735 , int> = 0>
736 _LIBCPP_INLINE_VISIBILITY
737 explicit optional(const optional<_Up>& __v)
738 {
739 this->__construct_from(__v);
740 }
741
742 // LWG2756: conditionally explicit conversion from optional<_Up>&&
743 template <class _Up, _EnableIf<
744 _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_implicit<_Up>()
745 , int> = 0>
746 _LIBCPP_INLINE_VISIBILITY
747 optional(optional<_Up>&& __v)
748 {
749 this->__construct_from(_VSTD::move(__v));
750 }
751 template <class _Up, _EnableIf<
752 _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_explicit<_Up>()
753 , int> = 0>
754 _LIBCPP_INLINE_VISIBILITY
755 explicit optional(optional<_Up>&& __v)
756 {
757 this->__construct_from(_VSTD::move(__v));
758 }
759
760 _LIBCPP_INLINE_VISIBILITY
761 optional& operator=(nullopt_t) noexcept
762 {
763 reset();
764 return *this;
765 }
766
767 _LIBCPP_INLINE_VISIBILITY optional& operator=(const optional&) = default;
768 _LIBCPP_INLINE_VISIBILITY optional& operator=(optional&&) = default;
769
770 // LWG2756
771 template <class _Up = value_type,
772 class = _EnableIf<
773 _And<
774 _IsNotSame<__uncvref_t<_Up>, optional>,
775 _Or<
776 _IsNotSame<__uncvref_t<_Up>, value_type>,
777 _Not<is_scalar<value_type>>
778 >,
779 is_constructible<value_type, _Up>,
780 is_assignable<value_type&, _Up>
781 >::value>
782 >
783 _LIBCPP_INLINE_VISIBILITY
784 optional&
785 operator=(_Up&& __v)
786 {
787 if (this->has_value())
788 this->__get() = _VSTD::forward<_Up>(__v);
789 else
790 this->__construct(_VSTD::forward<_Up>(__v));
791 return *this;
792 }
793
794 // LWG2756
795 template <class _Up, _EnableIf<
796 _CheckOptionalLikeAssign<_Up, _Up const&>::template __enable_assign<_Up>()
797 , int> = 0>
798 _LIBCPP_INLINE_VISIBILITY
799 optional&
800 operator=(const optional<_Up>& __v)
801 {
802 this->__assign_from(__v);
803 return *this;
804 }
805
806 // LWG2756
807 template <class _Up, _EnableIf<
808 _CheckOptionalLikeCtor<_Up, _Up &&>::template __enable_assign<_Up>()
809 , int> = 0>
810 _LIBCPP_INLINE_VISIBILITY
811 optional&
812 operator=(optional<_Up>&& __v)
813 {
814 this->__assign_from(_VSTD::move(__v));
815 return *this;
816 }
817
818 template <class... _Args,
819 class = _EnableIf
820 <
821 is_constructible_v<value_type, _Args...>
822 >
823 >
824 _LIBCPP_INLINE_VISIBILITY
825 _Tp &
826 emplace(_Args&&... __args)
827 {
828 reset();
829 this->__construct(_VSTD::forward<_Args>(__args)...);
830 return this->__get();
831 }
832
833 template <class _Up, class... _Args,
834 class = _EnableIf
835 <
836 is_constructible_v<value_type, initializer_list<_Up>&, _Args...>
837 >
838 >
839 _LIBCPP_INLINE_VISIBILITY
840 _Tp &
841 emplace(initializer_list<_Up> __il, _Args&&... __args)
842 {
843 reset();
844 this->__construct(__il, _VSTD::forward<_Args>(__args)...);
845 return this->__get();
846 }
847
848 _LIBCPP_INLINE_VISIBILITY
849 void swap(optional& __opt)
850 noexcept(is_nothrow_move_constructible_v<value_type> &&
851 is_nothrow_swappable_v<value_type>)
852 {
853 if (this->has_value() == __opt.has_value())
854 {
855 using _VSTD::swap;
856 if (this->has_value())
857 swap(this->__get(), __opt.__get());
858 }
859 else
860 {
861 if (this->has_value())
862 {
863 __opt.__construct(_VSTD::move(this->__get()));
864 reset();
865 }
866 else
867 {
868 this->__construct(_VSTD::move(__opt.__get()));
869 __opt.reset();
870 }
871 }
872 }
873
874 _LIBCPP_INLINE_VISIBILITY
875 constexpr
876 add_pointer_t<value_type const>
877 operator->() const
878 {
879 _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value");
880#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
881 return _VSTD::addressof(this->__get());
882#else
883 return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get());
884#endif
885 }
886
887 _LIBCPP_INLINE_VISIBILITY
888 constexpr
889 add_pointer_t<value_type>
890 operator->()
891 {
892 _LIBCPP_ASSERT(this->has_value(), "optional operator-> called for disengaged value");
893#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
894 return _VSTD::addressof(this->__get());
895#else
896 return __operator_arrow(__has_operator_addressof<value_type>{}, this->__get());
897#endif
898 }
899
900 _LIBCPP_INLINE_VISIBILITY
901 constexpr
902 const value_type&
903 operator*() const&
904 {
905 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
906 return this->__get();
907 }
908
909 _LIBCPP_INLINE_VISIBILITY
910 constexpr
911 value_type&
912 operator*() &
913 {
914 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
915 return this->__get();
916 }
917
918 _LIBCPP_INLINE_VISIBILITY
919 constexpr
920 value_type&&
921 operator*() &&
922 {
923 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
924 return _VSTD::move(this->__get());
925 }
926
927 _LIBCPP_INLINE_VISIBILITY
928 constexpr
929 const value_type&&
930 operator*() const&&
931 {
932 _LIBCPP_ASSERT(this->has_value(), "optional operator* called for disengaged value");
933 return _VSTD::move(this->__get());
934 }
935
936 _LIBCPP_INLINE_VISIBILITY
937 constexpr explicit operator bool() const noexcept { return has_value(); }
938
939 using __base::has_value;
940 using __base::__get;
941
942 _LIBCPP_INLINE_VISIBILITY
943 _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
944 constexpr value_type const& value() const&
945 {
946 if (!this->has_value())
947 __throw_bad_optional_access();
948 return this->__get();
949 }
950
951 _LIBCPP_INLINE_VISIBILITY
952 _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
953 constexpr value_type& value() &
954 {
955 if (!this->has_value())
956 __throw_bad_optional_access();
957 return this->__get();
958 }
959
960 _LIBCPP_INLINE_VISIBILITY
961 _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
962 constexpr value_type&& value() &&
963 {
964 if (!this->has_value())
965 __throw_bad_optional_access();
966 return _VSTD::move(this->__get());
967 }
968
969 _LIBCPP_INLINE_VISIBILITY
970 _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS
971 constexpr value_type const&& value() const&&
972 {
973 if (!this->has_value())
974 __throw_bad_optional_access();
975 return _VSTD::move(this->__get());
976 }
977
978 template <class _Up>
979 _LIBCPP_INLINE_VISIBILITY
980 constexpr value_type value_or(_Up&& __v) const&
981 {
982 static_assert(is_copy_constructible_v<value_type>,
983 "optional<T>::value_or: T must be copy constructible");
984 static_assert(is_convertible_v<_Up, value_type>,
985 "optional<T>::value_or: U must be convertible to T");
986 return this->has_value() ? this->__get() :
987 static_cast<value_type>(_VSTD::forward<_Up>(__v));
988 }
989
990 template <class _Up>
991 _LIBCPP_INLINE_VISIBILITY
992 constexpr value_type value_or(_Up&& __v) &&
993 {
994 static_assert(is_move_constructible_v<value_type>,
995 "optional<T>::value_or: T must be move constructible");
996 static_assert(is_convertible_v<_Up, value_type>,
997 "optional<T>::value_or: U must be convertible to T");
998 return this->has_value() ? _VSTD::move(this->__get()) :
999 static_cast<value_type>(_VSTD::forward<_Up>(__v));
1000 }
1001
1002 using __base::reset;
1003
1004private:
1005 template <class _Up>
1006 _LIBCPP_INLINE_VISIBILITY
1007 static _Up*
1008 __operator_arrow(true_type, _Up& __x)
1009 {
1010 return _VSTD::addressof(__x);
1011 }
1012
1013 template <class _Up>
1014 _LIBCPP_INLINE_VISIBILITY
1015 static constexpr _Up*
1016 __operator_arrow(false_type, _Up& __x)
1017 {
1018 return &__x;
1019 }
1020};
1021
1022#ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
1023template<class T>
1024 optional(T) -> optional<T>;
1025#endif
1026
1027// Comparisons between optionals
1028template <class _Tp, class _Up>
1029_LIBCPP_INLINE_VISIBILITY constexpr
1030_EnableIf<
1031 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
1032 _VSTD::declval<const _Up&>()), bool>,
1033 bool
1034>
1035operator==(const optional<_Tp>& __x, const optional<_Up>& __y)
1036{
1037 if (static_cast<bool>(__x) != static_cast<bool>(__y))
1038 return false;
1039 if (!static_cast<bool>(__x))
1040 return true;
1041 return *__x == *__y;
1042}
1043
1044template <class _Tp, class _Up>
1045_LIBCPP_INLINE_VISIBILITY constexpr
1046_EnableIf<
1047 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
1048 _VSTD::declval<const _Up&>()), bool>,
1049 bool
1050>
1051operator!=(const optional<_Tp>& __x, const optional<_Up>& __y)
1052{
1053 if (static_cast<bool>(__x) != static_cast<bool>(__y))
1054 return true;
1055 if (!static_cast<bool>(__x))
1056 return false;
1057 return *__x != *__y;
1058}
1059
1060template <class _Tp, class _Up>
1061_LIBCPP_INLINE_VISIBILITY constexpr
1062_EnableIf<
1063 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
1064 _VSTD::declval<const _Up&>()), bool>,
1065 bool
1066>
1067operator<(const optional<_Tp>& __x, const optional<_Up>& __y)
1068{
1069 if (!static_cast<bool>(__y))
1070 return false;
1071 if (!static_cast<bool>(__x))
1072 return true;
1073 return *__x < *__y;
1074}
1075
1076template <class _Tp, class _Up>
1077_LIBCPP_INLINE_VISIBILITY constexpr
1078_EnableIf<
1079 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
1080 _VSTD::declval<const _Up&>()), bool>,
1081 bool
1082>
1083operator>(const optional<_Tp>& __x, const optional<_Up>& __y)
1084{
1085 if (!static_cast<bool>(__x))
1086 return false;
1087 if (!static_cast<bool>(__y))
1088 return true;
1089 return *__x > *__y;
1090}
1091
1092template <class _Tp, class _Up>
1093_LIBCPP_INLINE_VISIBILITY constexpr
1094_EnableIf<
1095 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
1096 _VSTD::declval<const _Up&>()), bool>,
1097 bool
1098>
1099operator<=(const optional<_Tp>& __x, const optional<_Up>& __y)
1100{
1101 if (!static_cast<bool>(__x))
1102 return true;
1103 if (!static_cast<bool>(__y))
1104 return false;
1105 return *__x <= *__y;
1106}
1107
1108template <class _Tp, class _Up>
1109_LIBCPP_INLINE_VISIBILITY constexpr
1110_EnableIf<
1111 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
1112 _VSTD::declval<const _Up&>()), bool>,
1113 bool
1114>
1115operator>=(const optional<_Tp>& __x, const optional<_Up>& __y)
1116{
1117 if (!static_cast<bool>(__y))
1118 return true;
1119 if (!static_cast<bool>(__x))
1120 return false;
1121 return *__x >= *__y;
1122}
1123
1124// Comparisons with nullopt
1125template <class _Tp>
1126_LIBCPP_INLINE_VISIBILITY constexpr
1127bool
1128operator==(const optional<_Tp>& __x, nullopt_t) noexcept
1129{
1130 return !static_cast<bool>(__x);
1131}
1132
1133template <class _Tp>
1134_LIBCPP_INLINE_VISIBILITY constexpr
1135bool
1136operator==(nullopt_t, const optional<_Tp>& __x) noexcept
1137{
1138 return !static_cast<bool>(__x);
1139}
1140
1141template <class _Tp>
1142_LIBCPP_INLINE_VISIBILITY constexpr
1143bool
1144operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
1145{
1146 return static_cast<bool>(__x);
1147}
1148
1149template <class _Tp>
1150_LIBCPP_INLINE_VISIBILITY constexpr
1151bool
1152operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
1153{
1154 return static_cast<bool>(__x);
1155}
1156
1157template <class _Tp>
1158_LIBCPP_INLINE_VISIBILITY constexpr
1159bool
1160operator<(const optional<_Tp>&, nullopt_t) noexcept
1161{
1162 return false;
1163}
1164
1165template <class _Tp>
1166_LIBCPP_INLINE_VISIBILITY constexpr
1167bool
1168operator<(nullopt_t, const optional<_Tp>& __x) noexcept
1169{
1170 return static_cast<bool>(__x);
1171}
1172
1173template <class _Tp>
1174_LIBCPP_INLINE_VISIBILITY constexpr
1175bool
1176operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
1177{
1178 return !static_cast<bool>(__x);
1179}
1180
1181template <class _Tp>
1182_LIBCPP_INLINE_VISIBILITY constexpr
1183bool
1184operator<=(nullopt_t, const optional<_Tp>&) noexcept
1185{
1186 return true;
1187}
1188
1189template <class _Tp>
1190_LIBCPP_INLINE_VISIBILITY constexpr
1191bool
1192operator>(const optional<_Tp>& __x, nullopt_t) noexcept
1193{
1194 return static_cast<bool>(__x);
1195}
1196
1197template <class _Tp>
1198_LIBCPP_INLINE_VISIBILITY constexpr
1199bool
1200operator>(nullopt_t, const optional<_Tp>&) noexcept
1201{
1202 return false;
1203}
1204
1205template <class _Tp>
1206_LIBCPP_INLINE_VISIBILITY constexpr
1207bool
1208operator>=(const optional<_Tp>&, nullopt_t) noexcept
1209{
1210 return true;
1211}
1212
1213template <class _Tp>
1214_LIBCPP_INLINE_VISIBILITY constexpr
1215bool
1216operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
1217{
1218 return !static_cast<bool>(__x);
1219}
1220
1221// Comparisons with T
1222template <class _Tp, class _Up>
1223_LIBCPP_INLINE_VISIBILITY constexpr
1224_EnableIf<
1225 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
1226 _VSTD::declval<const _Up&>()), bool>,
1227 bool
1228>
1229operator==(const optional<_Tp>& __x, const _Up& __v)
1230{
1231 return static_cast<bool>(__x) ? *__x == __v : false;
1232}
1233
1234template <class _Tp, class _Up>
1235_LIBCPP_INLINE_VISIBILITY constexpr
1236_EnableIf<
1237 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() ==
1238 _VSTD::declval<const _Up&>()), bool>,
1239 bool
1240>
1241operator==(const _Tp& __v, const optional<_Up>& __x)
1242{
1243 return static_cast<bool>(__x) ? __v == *__x : false;
1244}
1245
1246template <class _Tp, class _Up>
1247_LIBCPP_INLINE_VISIBILITY constexpr
1248_EnableIf<
1249 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
1250 _VSTD::declval<const _Up&>()), bool>,
1251 bool
1252>
1253operator!=(const optional<_Tp>& __x, const _Up& __v)
1254{
1255 return static_cast<bool>(__x) ? *__x != __v : true;
1256}
1257
1258template <class _Tp, class _Up>
1259_LIBCPP_INLINE_VISIBILITY constexpr
1260_EnableIf<
1261 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() !=
1262 _VSTD::declval<const _Up&>()), bool>,
1263 bool
1264>
1265operator!=(const _Tp& __v, const optional<_Up>& __x)
1266{
1267 return static_cast<bool>(__x) ? __v != *__x : true;
1268}
1269
1270template <class _Tp, class _Up>
1271_LIBCPP_INLINE_VISIBILITY constexpr
1272_EnableIf<
1273 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
1274 _VSTD::declval<const _Up&>()), bool>,
1275 bool
1276>
1277operator<(const optional<_Tp>& __x, const _Up& __v)
1278{
1279 return static_cast<bool>(__x) ? *__x < __v : true;
1280}
1281
1282template <class _Tp, class _Up>
1283_LIBCPP_INLINE_VISIBILITY constexpr
1284_EnableIf<
1285 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <
1286 _VSTD::declval<const _Up&>()), bool>,
1287 bool
1288>
1289operator<(const _Tp& __v, const optional<_Up>& __x)
1290{
1291 return static_cast<bool>(__x) ? __v < *__x : false;
1292}
1293
1294template <class _Tp, class _Up>
1295_LIBCPP_INLINE_VISIBILITY constexpr
1296_EnableIf<
1297 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
1298 _VSTD::declval<const _Up&>()), bool>,
1299 bool
1300>
1301operator<=(const optional<_Tp>& __x, const _Up& __v)
1302{
1303 return static_cast<bool>(__x) ? *__x <= __v : true;
1304}
1305
1306template <class _Tp, class _Up>
1307_LIBCPP_INLINE_VISIBILITY constexpr
1308_EnableIf<
1309 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() <=
1310 _VSTD::declval<const _Up&>()), bool>,
1311 bool
1312>
1313operator<=(const _Tp& __v, const optional<_Up>& __x)
1314{
1315 return static_cast<bool>(__x) ? __v <= *__x : false;
1316}
1317
1318template <class _Tp, class _Up>
1319_LIBCPP_INLINE_VISIBILITY constexpr
1320_EnableIf<
1321 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
1322 _VSTD::declval<const _Up&>()), bool>,
1323 bool
1324>
1325operator>(const optional<_Tp>& __x, const _Up& __v)
1326{
1327 return static_cast<bool>(__x) ? *__x > __v : false;
1328}
1329
1330template <class _Tp, class _Up>
1331_LIBCPP_INLINE_VISIBILITY constexpr
1332_EnableIf<
1333 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >
1334 _VSTD::declval<const _Up&>()), bool>,
1335 bool
1336>
1337operator>(const _Tp& __v, const optional<_Up>& __x)
1338{
1339 return static_cast<bool>(__x) ? __v > *__x : true;
1340}
1341
1342template <class _Tp, class _Up>
1343_LIBCPP_INLINE_VISIBILITY constexpr
1344_EnableIf<
1345 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
1346 _VSTD::declval<const _Up&>()), bool>,
1347 bool
1348>
1349operator>=(const optional<_Tp>& __x, const _Up& __v)
1350{
1351 return static_cast<bool>(__x) ? *__x >= __v : false;
1352}
1353
1354template <class _Tp, class _Up>
1355_LIBCPP_INLINE_VISIBILITY constexpr
1356_EnableIf<
1357 is_convertible_v<decltype(_VSTD::declval<const _Tp&>() >=
1358 _VSTD::declval<const _Up&>()), bool>,
1359 bool
1360>
1361operator>=(const _Tp& __v, const optional<_Up>& __x)
1362{
1363 return static_cast<bool>(__x) ? __v >= *__x : true;
1364}
1365
1366
1367template <class _Tp>
1368inline _LIBCPP_INLINE_VISIBILITY
1369_EnableIf<
1370 is_move_constructible_v<_Tp> && is_swappable_v<_Tp>,
1371 void
1372>
1373swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
1374{
1375 __x.swap(__y);
1376}
1377
1378template <class _Tp>
1379_LIBCPP_INLINE_VISIBILITY constexpr
1380optional<decay_t<_Tp>> make_optional(_Tp&& __v)
1381{
1382 return optional<decay_t<_Tp>>(_VSTD::forward<_Tp>(__v));
1383}
1384
1385template <class _Tp, class... _Args>
1386_LIBCPP_INLINE_VISIBILITY constexpr
1387optional<_Tp> make_optional(_Args&&... __args)
1388{
1389 return optional<_Tp>(in_place, _VSTD::forward<_Args>(__args)...);
1390}
1391
1392template <class _Tp, class _Up, class... _Args>
1393_LIBCPP_INLINE_VISIBILITY constexpr
1394optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args)
1395{
1396 return optional<_Tp>(in_place, __il, _VSTD::forward<_Args>(__args)...);
1397}
1398
1399template <class _Tp>
1400struct _LIBCPP_TEMPLATE_VIS hash<
1401 __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>>
1402>
1403{
1404 typedef optional<_Tp> argument_type;
1405 typedef size_t result_type;
1406
1407 _LIBCPP_INLINE_VISIBILITY
1408 result_type operator()(const argument_type& __opt) const
1409 {
1410 return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
1411 }
1412};
1413
1414_LIBCPP_END_NAMESPACE_STD
1415
1416#endif // _LIBCPP_STD_VER > 14
1417
1418_LIBCPP_POP_MACROS
1419
1420#endif // _LIBCPP_OPTIONAL
1421