1// -*- C++ -*-
2//===-------------------------- optional ----------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_EXPERIMENTAL_OPTIONAL
12#define _LIBCPP_EXPERIMENTAL_OPTIONAL
13
14/*
15    optional synopsis
16
17// C++1y
18
19namespace std { namespace experimental { inline namespace fundamentals_v1 {
20
21    // 5.3, optional for object types
22    template <class T> class optional;
23
24    // 5.4, In-place construction
25    struct in_place_t{};
26    constexpr in_place_t in_place{};
27
28    // 5.5, No-value state indicator
29    struct nullopt_t{see below};
30    constexpr nullopt_t nullopt(unspecified);
31
32    // 5.6, Class bad_optional_access
33    class bad_optional_access;
34
35    // 5.7, Relational operators
36    template <class T>
37      constexpr bool operator==(const optional<T>&, const optional<T>&);
38    template <class T>
39      constexpr bool operator!=(const optional<T>&, const optional<T>&);
40    template <class T>
41      constexpr bool operator<(const optional<T>&, const optional<T>&);
42    template <class T>
43      constexpr bool operator>(const optional<T>&, const optional<T>&);
44    template <class T>
45      constexpr bool operator<=(const optional<T>&, const optional<T>&);
46    template <class T>
47      constexpr bool operator>=(const optional<T>&, const optional<T>&);
48
49    // 5.8, Comparison with nullopt
50    template <class T> constexpr bool operator==(const optional<T>&, nullopt_t) noexcept;
51    template <class T> constexpr bool operator==(nullopt_t, const optional<T>&) noexcept;
52    template <class T> constexpr bool operator!=(const optional<T>&, nullopt_t) noexcept;
53    template <class T> constexpr bool operator!=(nullopt_t, const optional<T>&) noexcept;
54    template <class T> constexpr bool operator<(const optional<T>&, nullopt_t) noexcept;
55    template <class T> constexpr bool operator<(nullopt_t, const optional<T>&) noexcept;
56    template <class T> constexpr bool operator<=(const optional<T>&, nullopt_t) noexcept;
57    template <class T> constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept;
58    template <class T> constexpr bool operator>(const optional<T>&, nullopt_t) noexcept;
59    template <class T> constexpr bool operator>(nullopt_t, const optional<T>&) noexcept;
60    template <class T> constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept;
61    template <class T> constexpr bool operator>=(nullopt_t, const optional<T>&) noexcept;
62
63    // 5.9, Comparison with T
64    template <class T> constexpr bool operator==(const optional<T>&, const T&);
65    template <class T> constexpr bool operator==(const T&, const optional<T>&);
66    template <class T> constexpr bool operator!=(const optional<T>&, const T&);
67    template <class T> constexpr bool operator!=(const T&, const optional<T>&);
68    template <class T> constexpr bool operator<(const optional<T>&, const T&);
69    template <class T> constexpr bool operator<(const T&, const optional<T>&);
70    template <class T> constexpr bool operator<=(const optional<T>&, const T&);
71    template <class T> constexpr bool operator<=(const T&, const optional<T>&);
72    template <class T> constexpr bool operator>(const optional<T>&, const T&);
73    template <class T> constexpr bool operator>(const T&, const optional<T>&);
74    template <class T> constexpr bool operator>=(const optional<T>&, const T&);
75    template <class T> constexpr bool operator>=(const T&, const optional<T>&);
76
77    // 5.10, Specialized algorithms
78    template <class T> void swap(optional<T>&, optional<T>&) noexcept(see below);
79    template <class T> constexpr optional<see below> make_optional(T&&);
80
81	template <class T>
82	class optional
83	{
84	public:
85	  typedef T value_type;
86
87	  // 5.3.1, Constructors
88	  constexpr optional() noexcept;
89	  constexpr optional(nullopt_t) noexcept;
90	  optional(const optional&);
91	  optional(optional&&) noexcept(see below);
92	  constexpr optional(const T&);
93	  constexpr optional(T&&);
94	  template <class... Args> constexpr explicit optional(in_place_t, Args&&...);
95	  template <class U, class... Args>
96		constexpr explicit optional(in_place_t, initializer_list<U>, Args&&...);
97
98	  // 5.3.2, Destructor
99	  ~optional();
100
101	  // 5.3.3, Assignment
102	  optional& operator=(nullopt_t) noexcept;
103	  optional& operator=(const optional&);
104	  optional& operator=(optional&&) noexcept(see below);
105	  template <class U> optional& operator=(U&&);
106	  template <class... Args> void emplace(Args&&...);
107	  template <class U, class... Args>
108		void emplace(initializer_list<U>, Args&&...);
109
110	  // 5.3.4, Swap
111	  void swap(optional&) noexcept(see below);
112
113	  // 5.3.5, Observers
114	  constexpr T const* operator ->() const;
115	  constexpr T* operator ->();
116	  constexpr T const& operator *() const &;
117	  constexpr T& operator *() &;
118	  constexpr T&& operator *() &&;
119	  constexpr const T&& operator *() const &&;
120	  constexpr explicit operator bool() const noexcept;
121	  constexpr T const& value() const &;
122	  constexpr T& value() &;
123	  constexpr T&& value() &&;
124	  constexpr const T&& value() const &&;
125	  template <class U> constexpr T value_or(U&&) const &;
126	  template <class U> constexpr T value_or(U&&) &&;
127
128	private:
129	  T*   val;  // exposition only
130	};
131
132  } // namespace fundamentals_v1
133  } // namespace experimental
134
135  // 5.11, Hash support
136  template <class T> struct hash;
137  template <class T> struct hash<experimental::optional<T>>;
138
139} // namespace std
140
141*/
142
143#include <experimental/__config>
144#include <functional>
145#include <stdexcept>
146
147_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
148class _LIBCPP_EXCEPTION_ABI bad_optional_access
149    : public std::logic_error
150{
151public:
152	bad_optional_access() : std::logic_error("Bad optional Access") {}
153
154//	Get the key function ~bad_optional_access() into the dylib
155    virtual ~bad_optional_access() _NOEXCEPT;
156};
157
158_LIBCPP_END_NAMESPACE_EXPERIMENTAL
159
160
161#if _LIBCPP_STD_VER > 11
162
163#include <initializer_list>
164#include <type_traits>
165#include <new>
166#include <__functional_base>
167#include <__undef_min_max>
168#include <__debug>
169
170#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
171#pragma GCC system_header
172#endif
173
174_LIBCPP_BEGIN_NAMESPACE_LFTS
175
176struct in_place_t {};
177constexpr in_place_t in_place{};
178
179struct nullopt_t
180{
181    explicit constexpr nullopt_t(int) noexcept {}
182};
183
184constexpr nullopt_t nullopt{0};
185
186template <class _Tp, bool = is_trivially_destructible<_Tp>::value>
187class __optional_storage
188{
189protected:
190    typedef _Tp value_type;
191    union
192    {
193        char __null_state_;
194        value_type __val_;
195    };
196    bool __engaged_ = false;
197
198    _LIBCPP_INLINE_VISIBILITY
199    ~__optional_storage()
200    {
201        if (__engaged_)
202            __val_.~value_type();
203    }
204
205    _LIBCPP_INLINE_VISIBILITY
206    constexpr __optional_storage() noexcept
207        :  __null_state_('\0') {}
208
209    _LIBCPP_INLINE_VISIBILITY
210    __optional_storage(const __optional_storage& __x)
211        :  __engaged_(__x.__engaged_)
212        {
213            if (__engaged_)
214                ::new((void*)_VSTD::addressof(__val_)) value_type(__x.__val_);
215        }
216
217    _LIBCPP_INLINE_VISIBILITY
218    __optional_storage(__optional_storage&& __x)
219                      noexcept(is_nothrow_move_constructible<value_type>::value)
220        :  __engaged_(__x.__engaged_)
221        {
222            if (__engaged_)
223                ::new((void*)_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
224        }
225
226    _LIBCPP_INLINE_VISIBILITY
227    constexpr __optional_storage(const value_type& __v)
228        :  __val_(__v),
229           __engaged_(true) {}
230
231    _LIBCPP_INLINE_VISIBILITY
232    constexpr __optional_storage(value_type&& __v)
233        :  __val_(_VSTD::move(__v)),
234           __engaged_(true) {}
235
236    template <class... _Args>
237    _LIBCPP_INLINE_VISIBILITY
238    constexpr
239    explicit __optional_storage(in_place_t, _Args&&... __args)
240       :  __val_(_VSTD::forward<_Args>(__args)...),
241           __engaged_(true) {}
242};
243
244template <class _Tp>
245class __optional_storage<_Tp, true>
246{
247protected:
248    typedef _Tp value_type;
249    union
250    {
251        char __null_state_;
252        value_type __val_;
253    };
254    bool __engaged_ = false;
255
256    _LIBCPP_INLINE_VISIBILITY
257    constexpr __optional_storage() noexcept
258        :  __null_state_('\0') {}
259
260    _LIBCPP_INLINE_VISIBILITY
261    __optional_storage(const __optional_storage& __x)
262        :  __engaged_(__x.__engaged_)
263        {
264            if (__engaged_)
265                ::new((void*)_VSTD::addressof(__val_)) value_type(__x.__val_);
266        }
267
268    _LIBCPP_INLINE_VISIBILITY
269    __optional_storage(__optional_storage&& __x)
270                      noexcept(is_nothrow_move_constructible<value_type>::value)
271        :  __engaged_(__x.__engaged_)
272        {
273            if (__engaged_)
274                ::new((void*)_VSTD::addressof(__val_)) value_type(_VSTD::move(__x.__val_));
275        }
276
277    _LIBCPP_INLINE_VISIBILITY
278    constexpr __optional_storage(const value_type& __v)
279        :  __val_(__v),
280           __engaged_(true) {}
281
282    _LIBCPP_INLINE_VISIBILITY
283    constexpr __optional_storage(value_type&& __v)
284        :  __val_(_VSTD::move(__v)),
285           __engaged_(true) {}
286
287    template <class... _Args>
288    _LIBCPP_INLINE_VISIBILITY
289    constexpr
290    explicit __optional_storage(in_place_t, _Args&&... __args)
291       :  __val_(_VSTD::forward<_Args>(__args)...),
292           __engaged_(true) {}
293};
294
295template <class _Tp>
296class optional
297    : private __optional_storage<_Tp>
298{
299    typedef __optional_storage<_Tp> __base;
300public:
301    typedef _Tp value_type;
302
303    static_assert(!is_reference<value_type>::value,
304              "Instantiation of optional with a reference type is ill-formed.");
305    static_assert(!is_same<typename remove_cv<value_type>::type, in_place_t>::value,
306              "Instantiation of optional with a in_place_t type is ill-formed.");
307    static_assert(!is_same<typename remove_cv<value_type>::type, nullopt_t>::value,
308              "Instantiation of optional with a nullopt_t type is ill-formed.");
309    static_assert(is_object<value_type>::value,
310        "Instantiation of optional with a non-object type is undefined behavior.");
311    static_assert(is_nothrow_destructible<value_type>::value,
312        "Instantiation of optional with an object type that is not noexcept destructible is undefined behavior.");
313
314    _LIBCPP_INLINE_VISIBILITY constexpr optional() noexcept {}
315    _LIBCPP_INLINE_VISIBILITY optional(const optional&) = default;
316    _LIBCPP_INLINE_VISIBILITY optional(optional&&) = default;
317    _LIBCPP_INLINE_VISIBILITY ~optional() = default;
318    _LIBCPP_INLINE_VISIBILITY constexpr optional(nullopt_t) noexcept {}
319    _LIBCPP_INLINE_VISIBILITY constexpr optional(const value_type& __v)
320        : __base(__v) {}
321    _LIBCPP_INLINE_VISIBILITY constexpr optional(value_type&& __v)
322        : __base(_VSTD::move(__v)) {}
323
324    template <class... _Args,
325              class = typename enable_if
326                      <
327                           is_constructible<value_type, _Args...>::value
328                      >::type
329             >
330    _LIBCPP_INLINE_VISIBILITY
331    constexpr
332    explicit optional(in_place_t, _Args&&... __args)
333        : __base(in_place, _VSTD::forward<_Args>(__args)...) {}
334
335    template <class _Up, class... _Args,
336              class = typename enable_if
337                      <
338                           is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
339                      >::type
340             >
341    _LIBCPP_INLINE_VISIBILITY
342    constexpr
343    explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
344        : __base(in_place, __il, _VSTD::forward<_Args>(__args)...) {}
345
346    _LIBCPP_INLINE_VISIBILITY
347    optional& operator=(nullopt_t) noexcept
348    {
349        if (this->__engaged_)
350        {
351            this->__val_.~value_type();
352            this->__engaged_ = false;
353        }
354        return *this;
355    }
356
357    _LIBCPP_INLINE_VISIBILITY
358    optional&
359    operator=(const optional& __opt)
360    {
361        if (this->__engaged_ == __opt.__engaged_)
362        {
363            if (this->__engaged_)
364                this->__val_ = __opt.__val_;
365        }
366        else
367        {
368            if (this->__engaged_)
369                this->__val_.~value_type();
370            else
371                ::new((void*)_VSTD::addressof(this->__val_)) value_type(__opt.__val_);
372            this->__engaged_ = __opt.__engaged_;
373        }
374        return *this;
375    }
376
377    _LIBCPP_INLINE_VISIBILITY
378    optional&
379    operator=(optional&& __opt)
380        noexcept(is_nothrow_move_assignable<value_type>::value &&
381                 is_nothrow_move_constructible<value_type>::value)
382    {
383        if (this->__engaged_ == __opt.__engaged_)
384        {
385            if (this->__engaged_)
386                this->__val_ = _VSTD::move(__opt.__val_);
387        }
388        else
389        {
390            if (this->__engaged_)
391                this->__val_.~value_type();
392            else
393                ::new((void*)_VSTD::addressof(this->__val_))
394                    value_type(_VSTD::move(__opt.__val_));
395            this->__engaged_ = __opt.__engaged_;
396        }
397        return *this;
398    }
399
400    template <class _Up,
401              class = typename enable_if
402                      <
403                          is_same<typename remove_reference<_Up>::type, value_type>::value &&
404                          is_constructible<value_type, _Up>::value &&
405                          is_assignable<value_type&, _Up>::value
406                      >::type
407             >
408    _LIBCPP_INLINE_VISIBILITY
409    optional&
410    operator=(_Up&& __v)
411    {
412        if (this->__engaged_)
413            this->__val_ = _VSTD::forward<_Up>(__v);
414        else
415        {
416            ::new((void*)_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v));
417            this->__engaged_ = true;
418        }
419        return *this;
420    }
421
422    template <class... _Args,
423              class = typename enable_if
424                      <
425                          is_constructible<value_type, _Args...>::value
426                      >::type
427             >
428    _LIBCPP_INLINE_VISIBILITY
429    void
430    emplace(_Args&&... __args)
431    {
432        *this = nullopt;
433        ::new((void*)_VSTD::addressof(this->__val_))
434            value_type(_VSTD::forward<_Args>(__args)...);
435        this->__engaged_ = true;
436    }
437
438    template <class _Up, class... _Args,
439              class = typename enable_if
440                      <
441                          is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
442                      >::type
443             >
444    _LIBCPP_INLINE_VISIBILITY
445    void
446    emplace(initializer_list<_Up> __il, _Args&&... __args)
447    {
448        *this = nullopt;
449        ::new((void*)_VSTD::addressof(this->__val_))
450            value_type(__il, _VSTD::forward<_Args>(__args)...);
451        this->__engaged_ = true;
452    }
453
454    _LIBCPP_INLINE_VISIBILITY
455    void
456    swap(optional& __opt)
457        noexcept(is_nothrow_move_constructible<value_type>::value &&
458                 __is_nothrow_swappable<value_type>::value)
459    {
460        using _VSTD::swap;
461        if (this->__engaged_ == __opt.__engaged_)
462        {
463            if (this->__engaged_)
464                swap(this->__val_, __opt.__val_);
465        }
466        else
467        {
468            if (this->__engaged_)
469            {
470                ::new((void*)_VSTD::addressof(__opt.__val_))
471                    value_type(_VSTD::move(this->__val_));
472                this->__val_.~value_type();
473            }
474            else
475            {
476                ::new((void*)_VSTD::addressof(this->__val_))
477                    value_type(_VSTD::move(__opt.__val_));
478                __opt.__val_.~value_type();
479            }
480            swap(this->__engaged_, __opt.__engaged_);
481        }
482    }
483
484    _LIBCPP_INLINE_VISIBILITY
485    constexpr
486    value_type const*
487    operator->() const
488    {
489        _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
490#ifndef _LIBCPP_HAS_NO_BUILTIN_ADDRESSOF
491        return __builtin_addressof(this->__val_);
492#else
493        return __operator_arrow(__has_operator_addressof<value_type>{});
494#endif
495    }
496
497    _LIBCPP_INLINE_VISIBILITY
498    value_type*
499    operator->()
500    {
501        _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
502        return _VSTD::addressof(this->__val_);
503    }
504
505    _LIBCPP_INLINE_VISIBILITY
506    constexpr
507    const value_type&
508    operator*() const
509    {
510        _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
511        return this->__val_;
512    }
513
514    _LIBCPP_INLINE_VISIBILITY
515    value_type&
516    operator*()
517    {
518        _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
519        return this->__val_;
520    }
521
522    _LIBCPP_INLINE_VISIBILITY
523    constexpr explicit operator bool() const noexcept {return this->__engaged_;}
524
525	_LIBCPP_NORETURN _LIBCPP_INLINE_VISIBILITY
526	constexpr void __throw_bad_optional_access() const
527	{
528#ifndef _LIBCPP_NO_EXCEPTIONS
529        throw bad_optional_access();
530#else
531        _VSTD::abort();
532#endif
533	}
534
535    _LIBCPP_INLINE_VISIBILITY
536    constexpr value_type const& value() const
537    {
538        if (!this->__engaged_)
539            __throw_bad_optional_access();
540        return this->__val_;
541    }
542
543    _LIBCPP_INLINE_VISIBILITY
544    value_type& value()
545    {
546        if (!this->__engaged_)
547            __throw_bad_optional_access();
548        return this->__val_;
549    }
550
551    template <class _Up>
552    _LIBCPP_INLINE_VISIBILITY
553    constexpr value_type value_or(_Up&& __v) const&
554    {
555        static_assert(is_copy_constructible<value_type>::value,
556                      "optional<T>::value_or: T must be copy constructible");
557        static_assert(is_convertible<_Up, value_type>::value,
558                      "optional<T>::value_or: U must be convertible to T");
559        return this->__engaged_ ? this->__val_ :
560                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
561    }
562
563    template <class _Up>
564    _LIBCPP_INLINE_VISIBILITY
565    value_type value_or(_Up&& __v) &&
566    {
567        static_assert(is_move_constructible<value_type>::value,
568                      "optional<T>::value_or: T must be move constructible");
569        static_assert(is_convertible<_Up, value_type>::value,
570                      "optional<T>::value_or: U must be convertible to T");
571        return this->__engaged_ ? _VSTD::move(this->__val_) :
572                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
573    }
574
575private:
576    _LIBCPP_INLINE_VISIBILITY
577    value_type const*
578    __operator_arrow(true_type) const
579    {
580        return _VSTD::addressof(this->__val_);
581    }
582
583    _LIBCPP_INLINE_VISIBILITY
584    constexpr
585    value_type const*
586    __operator_arrow(false_type) const
587    {
588        return &this->__val_;
589    }
590};
591
592// Comparisons between optionals
593template <class _Tp>
594inline _LIBCPP_INLINE_VISIBILITY
595constexpr
596bool
597operator==(const optional<_Tp>& __x, const optional<_Tp>& __y)
598{
599    if (static_cast<bool>(__x) != static_cast<bool>(__y))
600        return false;
601    if (!static_cast<bool>(__x))
602        return true;
603    return *__x == *__y;
604}
605
606template <class _Tp>
607inline _LIBCPP_INLINE_VISIBILITY
608constexpr
609bool
610operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y)
611{
612    return !(__x == __y);
613}
614
615template <class _Tp>
616inline _LIBCPP_INLINE_VISIBILITY
617constexpr
618bool
619operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
620{
621    if (!static_cast<bool>(__y))
622        return false;
623    if (!static_cast<bool>(__x))
624        return true;
625    return *__x < *__y;
626}
627
628template <class _Tp>
629inline _LIBCPP_INLINE_VISIBILITY
630constexpr
631bool
632operator>(const optional<_Tp>& __x, const optional<_Tp>& __y)
633{
634    return __y < __x;
635}
636
637template <class _Tp>
638inline _LIBCPP_INLINE_VISIBILITY
639constexpr
640bool
641operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y)
642{
643    return !(__y < __x);
644}
645
646template <class _Tp>
647inline _LIBCPP_INLINE_VISIBILITY
648constexpr
649bool
650operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y)
651{
652    return !(__x < __y);
653}
654
655
656// Comparisons with nullopt
657template <class _Tp>
658inline _LIBCPP_INLINE_VISIBILITY
659constexpr
660bool
661operator==(const optional<_Tp>& __x, nullopt_t) noexcept
662{
663    return !static_cast<bool>(__x);
664}
665
666template <class _Tp>
667inline _LIBCPP_INLINE_VISIBILITY
668constexpr
669bool
670operator==(nullopt_t, const optional<_Tp>& __x) noexcept
671{
672    return !static_cast<bool>(__x);
673}
674
675template <class _Tp>
676inline _LIBCPP_INLINE_VISIBILITY
677constexpr
678bool
679operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
680{
681    return static_cast<bool>(__x);
682}
683
684template <class _Tp>
685inline _LIBCPP_INLINE_VISIBILITY
686constexpr
687bool
688operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
689{
690    return static_cast<bool>(__x);
691}
692
693template <class _Tp>
694inline _LIBCPP_INLINE_VISIBILITY
695constexpr
696bool
697operator<(const optional<_Tp>&, nullopt_t) noexcept
698{
699    return false;
700}
701
702template <class _Tp>
703inline _LIBCPP_INLINE_VISIBILITY
704constexpr
705bool
706operator<(nullopt_t, const optional<_Tp>& __x) noexcept
707{
708    return static_cast<bool>(__x);
709}
710
711template <class _Tp>
712inline _LIBCPP_INLINE_VISIBILITY
713constexpr
714bool
715operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
716{
717    return !static_cast<bool>(__x);
718}
719
720template <class _Tp>
721inline _LIBCPP_INLINE_VISIBILITY
722constexpr
723bool
724operator<=(nullopt_t, const optional<_Tp>&) noexcept
725{
726    return true;
727}
728
729template <class _Tp>
730inline _LIBCPP_INLINE_VISIBILITY
731constexpr
732bool
733operator>(const optional<_Tp>& __x, nullopt_t) noexcept
734{
735    return static_cast<bool>(__x);
736}
737
738template <class _Tp>
739inline _LIBCPP_INLINE_VISIBILITY
740constexpr
741bool
742operator>(nullopt_t, const optional<_Tp>&) noexcept
743{
744    return false;
745}
746
747template <class _Tp>
748inline _LIBCPP_INLINE_VISIBILITY
749constexpr
750bool
751operator>=(const optional<_Tp>&, nullopt_t) noexcept
752{
753    return true;
754}
755
756template <class _Tp>
757inline _LIBCPP_INLINE_VISIBILITY
758constexpr
759bool
760operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
761{
762    return !static_cast<bool>(__x);
763}
764
765// Comparisons with T
766template <class _Tp>
767inline _LIBCPP_INLINE_VISIBILITY
768constexpr
769bool
770operator==(const optional<_Tp>& __x, const _Tp& __v)
771{
772    return static_cast<bool>(__x) ? *__x == __v : false;
773}
774
775template <class _Tp>
776inline _LIBCPP_INLINE_VISIBILITY
777constexpr
778bool
779operator==(const _Tp& __v, const optional<_Tp>& __x)
780{
781    return static_cast<bool>(__x) ? *__x == __v : false;
782}
783
784template <class _Tp>
785inline _LIBCPP_INLINE_VISIBILITY
786constexpr
787bool
788operator!=(const optional<_Tp>& __x, const _Tp& __v)
789{
790    return static_cast<bool>(__x) ? !(*__x == __v) : true;
791}
792
793template <class _Tp>
794inline _LIBCPP_INLINE_VISIBILITY
795constexpr
796bool
797operator!=(const _Tp& __v, const optional<_Tp>& __x)
798{
799    return static_cast<bool>(__x) ? !(*__x == __v) : true;
800}
801
802template <class _Tp>
803inline _LIBCPP_INLINE_VISIBILITY
804constexpr
805bool
806operator<(const optional<_Tp>& __x, const _Tp& __v)
807{
808    return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true;
809}
810
811template <class _Tp>
812inline _LIBCPP_INLINE_VISIBILITY
813constexpr
814bool
815operator<(const _Tp& __v, const optional<_Tp>& __x)
816{
817    return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false;
818}
819
820template <class _Tp>
821inline _LIBCPP_INLINE_VISIBILITY
822constexpr
823bool
824operator<=(const optional<_Tp>& __x, const _Tp& __v)
825{
826    return !(__x > __v);
827}
828
829template <class _Tp>
830inline _LIBCPP_INLINE_VISIBILITY
831constexpr
832bool
833operator<=(const _Tp& __v, const optional<_Tp>& __x)
834{
835    return !(__v > __x);
836}
837
838template <class _Tp>
839inline _LIBCPP_INLINE_VISIBILITY
840constexpr
841bool
842operator>(const optional<_Tp>& __x, const _Tp& __v)
843{
844    return static_cast<bool>(__x) ? __v < __x : false;
845}
846
847template <class _Tp>
848inline _LIBCPP_INLINE_VISIBILITY
849constexpr
850bool
851operator>(const _Tp& __v, const optional<_Tp>& __x)
852{
853    return static_cast<bool>(__x) ? __x < __v : true;
854}
855
856template <class _Tp>
857inline _LIBCPP_INLINE_VISIBILITY
858constexpr
859bool
860operator>=(const optional<_Tp>& __x, const _Tp& __v)
861{
862    return !(__x < __v);
863}
864
865template <class _Tp>
866inline _LIBCPP_INLINE_VISIBILITY
867constexpr
868bool
869operator>=(const _Tp& __v, const optional<_Tp>& __x)
870{
871    return !(__v < __x);
872}
873
874
875template <class _Tp>
876inline _LIBCPP_INLINE_VISIBILITY
877void
878swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
879{
880    __x.swap(__y);
881}
882
883template <class _Tp>
884inline _LIBCPP_INLINE_VISIBILITY
885constexpr
886optional<typename decay<_Tp>::type>
887make_optional(_Tp&& __v)
888{
889    return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));
890}
891
892_LIBCPP_END_NAMESPACE_LFTS
893
894_LIBCPP_BEGIN_NAMESPACE_STD
895
896template <class _Tp>
897struct _LIBCPP_TEMPLATE_VIS hash<std::experimental::optional<_Tp> >
898{
899    typedef std::experimental::optional<_Tp> argument_type;
900    typedef size_t        result_type;
901
902    _LIBCPP_INLINE_VISIBILITY
903    result_type operator()(const argument_type& __opt) const _NOEXCEPT
904    {
905        return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0;
906    }
907};
908
909_LIBCPP_END_NAMESPACE_STD
910
911#endif  // _LIBCPP_STD_VER > 11
912
913#endif  // _LIBCPP_EXPERIMENTAL_OPTIONAL
914