1// -*- C++ -*-
2//===-------------------------- optional ----------------------------------===//
3//
4//                     The LLVM Compiler Infrastructure
5//
6// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
8//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_OPTIONAL
12#define _LIBCPP_OPTIONAL
13
14/*
15    optional synopsis
16
17// C++1y
18
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(_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(_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(_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(_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(_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(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_));
394            this->__engaged_ = __opt.__engaged_;
395        }
396        return *this;
397    }
398
399    template <class _Up,
400              class = typename enable_if
401                      <
402                          is_same<typename remove_reference<_Up>::type, value_type>::value &&
403                          is_constructible<value_type, _Up>::value &&
404                          is_assignable<value_type&, _Up>::value
405                      >::type
406             >
407    _LIBCPP_INLINE_VISIBILITY
408    optional&
409    operator=(_Up&& __v)
410    {
411        if (this->__engaged_)
412            this->__val_ = _VSTD::forward<_Up>(__v);
413        else
414        {
415            ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Up>(__v));
416            this->__engaged_ = true;
417        }
418        return *this;
419    }
420
421    template <class... _Args,
422              class = typename enable_if
423                      <
424                          is_constructible<value_type, _Args...>::value
425                      >::type
426             >
427    _LIBCPP_INLINE_VISIBILITY
428    void
429    emplace(_Args&&... __args)
430    {
431        *this = nullopt;
432        ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::forward<_Args>(__args)...);
433        this->__engaged_ = true;
434    }
435
436    template <class _Up, class... _Args,
437              class = typename enable_if
438                      <
439                          is_constructible<value_type, initializer_list<_Up>&, _Args...>::value
440                      >::type
441             >
442    _LIBCPP_INLINE_VISIBILITY
443    void
444    emplace(initializer_list<_Up> __il, _Args&&... __args)
445    {
446        *this = nullopt;
447        ::new(_VSTD::addressof(this->__val_)) value_type(__il, _VSTD::forward<_Args>(__args)...);
448        this->__engaged_ = true;
449    }
450
451    _LIBCPP_INLINE_VISIBILITY
452    void
453    swap(optional& __opt)
454        noexcept(is_nothrow_move_constructible<value_type>::value &&
455                 __is_nothrow_swappable<value_type>::value)
456    {
457        using _VSTD::swap;
458        if (this->__engaged_ == __opt.__engaged_)
459        {
460            if (this->__engaged_)
461                swap(this->__val_, __opt.__val_);
462        }
463        else
464        {
465            if (this->__engaged_)
466            {
467                ::new(_VSTD::addressof(__opt.__val_)) value_type(_VSTD::move(this->__val_));
468                this->__val_.~value_type();
469            }
470            else
471            {
472                ::new(_VSTD::addressof(this->__val_)) value_type(_VSTD::move(__opt.__val_));
473                __opt.__val_.~value_type();
474            }
475            swap(this->__engaged_, __opt.__engaged_);
476        }
477    }
478
479    _LIBCPP_INLINE_VISIBILITY
480    constexpr
481    value_type const*
482    operator->() const
483    {
484        _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
485        return __operator_arrow(__has_operator_addressof<value_type>{});
486    }
487
488    _LIBCPP_INLINE_VISIBILITY
489    value_type*
490    operator->()
491    {
492        _LIBCPP_ASSERT(this->__engaged_, "optional operator-> called for disengaged value");
493        return _VSTD::addressof(this->__val_);
494    }
495
496    _LIBCPP_INLINE_VISIBILITY
497    constexpr
498    const value_type&
499    operator*() const
500    {
501        _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
502        return this->__val_;
503    }
504
505    _LIBCPP_INLINE_VISIBILITY
506    value_type&
507    operator*()
508    {
509        _LIBCPP_ASSERT(this->__engaged_, "optional operator* called for disengaged value");
510        return this->__val_;
511    }
512
513    _LIBCPP_INLINE_VISIBILITY
514    constexpr explicit operator bool() const noexcept {return this->__engaged_;}
515
516    _LIBCPP_INLINE_VISIBILITY
517    constexpr value_type const& value() const
518    {
519        if (!this->__engaged_)
520            throw bad_optional_access();
521        return this->__val_;
522    }
523
524    _LIBCPP_INLINE_VISIBILITY
525    value_type& value()
526    {
527        if (!this->__engaged_)
528            throw bad_optional_access();
529        return this->__val_;
530    }
531
532    template <class _Up>
533    _LIBCPP_INLINE_VISIBILITY
534    constexpr value_type value_or(_Up&& __v) const&
535    {
536        static_assert(is_copy_constructible<value_type>::value,
537                      "optional<T>::value_or: T must be copy constructible");
538        static_assert(is_convertible<_Up, value_type>::value,
539                      "optional<T>::value_or: U must be convertible to T");
540        return this->__engaged_ ? this->__val_ :
541                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
542    }
543
544    template <class _Up>
545    _LIBCPP_INLINE_VISIBILITY
546    value_type value_or(_Up&& __v) &&
547    {
548        static_assert(is_move_constructible<value_type>::value,
549                      "optional<T>::value_or: T must be move constructible");
550        static_assert(is_convertible<_Up, value_type>::value,
551                      "optional<T>::value_or: U must be convertible to T");
552        return this->__engaged_ ? _VSTD::move(this->__val_) :
553                                  static_cast<value_type>(_VSTD::forward<_Up>(__v));
554    }
555
556private:
557    _LIBCPP_INLINE_VISIBILITY
558    value_type const*
559    __operator_arrow(true_type) const
560    {
561        return _VSTD::addressof(this->__val_);
562    }
563
564    _LIBCPP_INLINE_VISIBILITY
565    constexpr
566    value_type const*
567    __operator_arrow(false_type) const
568    {
569        return &this->__val_;
570    }
571};
572
573// Comparisons between optionals
574template <class _Tp>
575inline _LIBCPP_INLINE_VISIBILITY
576constexpr
577bool
578operator==(const optional<_Tp>& __x, const optional<_Tp>& __y)
579{
580    if (static_cast<bool>(__x) != static_cast<bool>(__y))
581        return false;
582    if (!static_cast<bool>(__x))
583        return true;
584    return *__x == *__y;
585}
586
587template <class _Tp>
588inline _LIBCPP_INLINE_VISIBILITY
589constexpr
590bool
591operator!=(const optional<_Tp>& __x, const optional<_Tp>& __y)
592{
593    return !(__x == __y);
594}
595
596template <class _Tp>
597inline _LIBCPP_INLINE_VISIBILITY
598constexpr
599bool
600operator<(const optional<_Tp>& __x, const optional<_Tp>& __y)
601{
602    if (!static_cast<bool>(__y))
603        return false;
604    if (!static_cast<bool>(__x))
605        return true;
606    return *__x < *__y;
607}
608
609template <class _Tp>
610inline _LIBCPP_INLINE_VISIBILITY
611constexpr
612bool
613operator>(const optional<_Tp>& __x, const optional<_Tp>& __y)
614{
615    return __y < __x;
616}
617
618template <class _Tp>
619inline _LIBCPP_INLINE_VISIBILITY
620constexpr
621bool
622operator<=(const optional<_Tp>& __x, const optional<_Tp>& __y)
623{
624    return !(__y < __x);
625}
626
627template <class _Tp>
628inline _LIBCPP_INLINE_VISIBILITY
629constexpr
630bool
631operator>=(const optional<_Tp>& __x, const optional<_Tp>& __y)
632{
633    return !(__x < __y);
634}
635
636
637// Comparisons with nullopt
638template <class _Tp>
639inline _LIBCPP_INLINE_VISIBILITY
640constexpr
641bool
642operator==(const optional<_Tp>& __x, nullopt_t) noexcept
643{
644    return !static_cast<bool>(__x);
645}
646
647template <class _Tp>
648inline _LIBCPP_INLINE_VISIBILITY
649constexpr
650bool
651operator==(nullopt_t, const optional<_Tp>& __x) noexcept
652{
653    return !static_cast<bool>(__x);
654}
655
656template <class _Tp>
657inline _LIBCPP_INLINE_VISIBILITY
658constexpr
659bool
660operator!=(const optional<_Tp>& __x, nullopt_t) noexcept
661{
662    return static_cast<bool>(__x);
663}
664
665template <class _Tp>
666inline _LIBCPP_INLINE_VISIBILITY
667constexpr
668bool
669operator!=(nullopt_t, const optional<_Tp>& __x) noexcept
670{
671    return static_cast<bool>(__x);
672}
673
674template <class _Tp>
675inline _LIBCPP_INLINE_VISIBILITY
676constexpr
677bool
678operator<(const optional<_Tp>&, nullopt_t) noexcept
679{
680    return false;
681}
682
683template <class _Tp>
684inline _LIBCPP_INLINE_VISIBILITY
685constexpr
686bool
687operator<(nullopt_t, const optional<_Tp>& __x) noexcept
688{
689    return static_cast<bool>(__x);
690}
691
692template <class _Tp>
693inline _LIBCPP_INLINE_VISIBILITY
694constexpr
695bool
696operator<=(const optional<_Tp>& __x, nullopt_t) noexcept
697{
698    return !static_cast<bool>(__x);
699}
700
701template <class _Tp>
702inline _LIBCPP_INLINE_VISIBILITY
703constexpr
704bool
705operator<=(nullopt_t, const optional<_Tp>& __x) noexcept
706{
707    return true;
708}
709
710template <class _Tp>
711inline _LIBCPP_INLINE_VISIBILITY
712constexpr
713bool
714operator>(const optional<_Tp>& __x, nullopt_t) noexcept
715{
716    return static_cast<bool>(__x);
717}
718
719template <class _Tp>
720inline _LIBCPP_INLINE_VISIBILITY
721constexpr
722bool
723operator>(nullopt_t, const optional<_Tp>& __x) noexcept
724{
725    return false;
726}
727
728template <class _Tp>
729inline _LIBCPP_INLINE_VISIBILITY
730constexpr
731bool
732operator>=(const optional<_Tp>&, nullopt_t) noexcept
733{
734    return true;
735}
736
737template <class _Tp>
738inline _LIBCPP_INLINE_VISIBILITY
739constexpr
740bool
741operator>=(nullopt_t, const optional<_Tp>& __x) noexcept
742{
743    return !static_cast<bool>(__x);
744}
745
746// Comparisons with T
747template <class _Tp>
748inline _LIBCPP_INLINE_VISIBILITY
749constexpr
750bool
751operator==(const optional<_Tp>& __x, const _Tp& __v)
752{
753    return static_cast<bool>(__x) ? *__x == __v : false;
754}
755
756template <class _Tp>
757inline _LIBCPP_INLINE_VISIBILITY
758constexpr
759bool
760operator==(const _Tp& __v, const optional<_Tp>& __x)
761{
762    return static_cast<bool>(__x) ? *__x == __v : false;
763}
764
765template <class _Tp>
766inline _LIBCPP_INLINE_VISIBILITY
767constexpr
768bool
769operator!=(const optional<_Tp>& __x, const _Tp& __v)
770{
771    return static_cast<bool>(__x) ? !(*__x == __v) : true;
772}
773
774template <class _Tp>
775inline _LIBCPP_INLINE_VISIBILITY
776constexpr
777bool
778operator!=(const _Tp& __v, const optional<_Tp>& __x)
779{
780    return static_cast<bool>(__x) ? !(*__x == __v) : true;
781}
782
783template <class _Tp>
784inline _LIBCPP_INLINE_VISIBILITY
785constexpr
786bool
787operator<(const optional<_Tp>& __x, const _Tp& __v)
788{
789    return static_cast<bool>(__x) ? less<_Tp>{}(*__x, __v) : true;
790}
791
792template <class _Tp>
793inline _LIBCPP_INLINE_VISIBILITY
794constexpr
795bool
796operator<(const _Tp& __v, const optional<_Tp>& __x)
797{
798    return static_cast<bool>(__x) ? less<_Tp>{}(__v, *__x) : false;
799}
800
801template <class _Tp>
802inline _LIBCPP_INLINE_VISIBILITY
803constexpr
804bool
805operator<=(const optional<_Tp>& __x, const _Tp& __v)
806{
807    return !(__x > __v);
808}
809
810template <class _Tp>
811inline _LIBCPP_INLINE_VISIBILITY
812constexpr
813bool
814operator<=(const _Tp& __v, const optional<_Tp>& __x)
815{
816    return !(__v > __x);
817}
818
819template <class _Tp>
820inline _LIBCPP_INLINE_VISIBILITY
821constexpr
822bool
823operator>(const optional<_Tp>& __x, const _Tp& __v)
824{
825    return static_cast<bool>(__x) ? __v < __x : false;
826}
827
828template <class _Tp>
829inline _LIBCPP_INLINE_VISIBILITY
830constexpr
831bool
832operator>(const _Tp& __v, const optional<_Tp>& __x)
833{
834    return static_cast<bool>(__x) ? __x < __v : true;
835}
836
837template <class _Tp>
838inline _LIBCPP_INLINE_VISIBILITY
839constexpr
840bool
841operator>=(const optional<_Tp>& __x, const _Tp& __v)
842{
843    return !(__x < __v);
844}
845
846template <class _Tp>
847inline _LIBCPP_INLINE_VISIBILITY
848constexpr
849bool
850operator>=(const _Tp& __v, const optional<_Tp>& __x)
851{
852    return !(__v < __x);
853}
854
855
856template <class _Tp>
857inline _LIBCPP_INLINE_VISIBILITY
858void
859swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y)))
860{
861    __x.swap(__y);
862}
863
864template <class _Tp>
865inline _LIBCPP_INLINE_VISIBILITY
866constexpr
867optional<typename decay<_Tp>::type>
868make_optional(_Tp&& __v)
869{
870    return optional<typename decay<_Tp>::type>(_VSTD::forward<_Tp>(__v));
871}
872
873_LIBCPP_END_NAMESPACE_LFTS
874
875_LIBCPP_BEGIN_NAMESPACE_STD
876
877template <class _Tp>
878struct _LIBCPP_TYPE_VIS_ONLY hash<std::experimental::optional<_Tp> >
879{
880    typedef std::experimental::optional<_Tp> argument_type;
881    typedef size_t        result_type;
882
883    _LIBCPP_INLINE_VISIBILITY
884    result_type operator()(const argument_type& __opt) const _NOEXCEPT
885    {
886        return static_cast<bool>(__opt) ? hash<_Tp>()(*__opt) : 0;
887    }
888};
889
890_LIBCPP_END_NAMESPACE_STD
891
892#endif  // _LIBCPP_STD_VER > 11
893
894#endif  // _LIBCPP_OPTIONAL
895