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