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