libcxx/include/future

   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_FUTURE
  11 #define _LIBCPP_FUTURE
  12
  13 /*
  14     future synopsis
  15
  16 namespace std
  17 {
  18
  19 enum class future_errc
  20 {
  21     future_already_retrieved = 1,
  22     promise_already_satisfied,
  23     no_state,
  24     broken_promise
  25 };
  26
  27 enum class launch
  28 {
  29     async = 1,
  30     deferred = 2,
  31     any = async | deferred
  32 };
  33
  34 enum class future_status
  35 {
  36     ready,
  37     timeout,
  38     deferred
  39 };
  40
  41 template <> struct is_error_code_enum<future_errc> : public true_type { };
  42 error_code make_error_code(future_errc e) noexcept;
  43 error_condition make_error_condition(future_errc e) noexcept;
  44
  45 const error_category& future_category() noexcept;
  46
  47 class future_error
  48     : public logic_error
  49 {
  50 public:
  51     future_error(error_code ec);  // exposition only
  52     explicit future_error(future_errc); // C++17
  53     const error_code& code() const noexcept;
  54     const char*       what() const noexcept;
  55 };
  56
  57 template <class R>
  58 class promise
  59 {
  60 public:
  61     promise();
  62     template <class Allocator>
  63         promise(allocator_arg_t, const Allocator& a);
  64     promise(promise&& rhs) noexcept;
  65     promise(const promise& rhs) = delete;
  66     ~promise();
  67
  68     // assignment
  69     promise& operator=(promise&& rhs) noexcept;
  70     promise& operator=(const promise& rhs) = delete;
  71     void swap(promise& other) noexcept;
  72
  73     // retrieving the result
  74     future<R> get_future();
  75
  76     // setting the result
  77     void set_value(const R& r);
  78     void set_value(R&& r);
  79     void set_exception(exception_ptr p);
  80
  81     // setting the result with deferred notification
  82     void set_value_at_thread_exit(const R& r);
  83     void set_value_at_thread_exit(R&& r);
  84     void set_exception_at_thread_exit(exception_ptr p);
  85 };
  86
  87 template <class R>
  88 class promise<R&>
  89 {
  90 public:
  91     promise();
  92     template <class Allocator>
  93         promise(allocator_arg_t, const Allocator& a);
  94     promise(promise&& rhs) noexcept;
  95     promise(const promise& rhs) = delete;
  96     ~promise();
  97
  98     // assignment
  99     promise& operator=(promise&& rhs) noexcept;
 100     promise& operator=(const promise& rhs) = delete;
 101     void swap(promise& other) noexcept;
 102
 103     // retrieving the result
 104     future<R&> get_future();
 105
 106     // setting the result
 107     void set_value(R& r);
 108     void set_exception(exception_ptr p);
 109
 110     // setting the result with deferred notification
 111     void set_value_at_thread_exit(R&);
 112     void set_exception_at_thread_exit(exception_ptr p);
 113 };
 114
 115 template <>
 116 class promise<void>
 117 {
 118 public:
 119     promise();
 120     template <class Allocator>
 121         promise(allocator_arg_t, const Allocator& a);
 122     promise(promise&& rhs) noexcept;
 123     promise(const promise& rhs) = delete;
 124     ~promise();
 125
 126     // assignment
 127     promise& operator=(promise&& rhs) noexcept;
 128     promise& operator=(const promise& rhs) = delete;
 129     void swap(promise& other) noexcept;
 130
 131     // retrieving the result
 132     future<void> get_future();
 133
 134     // setting the result
 135     void set_value();
 136     void set_exception(exception_ptr p);
 137
 138     // setting the result with deferred notification
 139     void set_value_at_thread_exit();
 140     void set_exception_at_thread_exit(exception_ptr p);
 141 };
 142
 143 template <class R> void swap(promise<R>& x, promise<R>& y) noexcept;
 144
 145 template <class R, class Alloc>
 146     struct uses_allocator<promise<R>, Alloc> : public true_type {};
 147
 148 template <class R>
 149 class future
 150 {
 151 public:
 152     future() noexcept;
 153     future(future&&) noexcept;
 154     future(const future& rhs) = delete;
 155     ~future();
 156     future& operator=(const future& rhs) = delete;
 157     future& operator=(future&&) noexcept;
 158     shared_future<R> share() noexcept;
 159
 160     // retrieving the value
 161     R get();
 162
 163     // functions to check state
 164     bool valid() const noexcept;
 165
 166     void wait() const;
 167     template <class Rep, class Period>
 168         future_status
 169         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 170     template <class Clock, class Duration>
 171         future_status
 172         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 173 };
 174
 175 template <class R>
 176 class future<R&>
 177 {
 178 public:
 179     future() noexcept;
 180     future(future&&) noexcept;
 181     future(const future& rhs) = delete;
 182     ~future();
 183     future& operator=(const future& rhs) = delete;
 184     future& operator=(future&&) noexcept;
 185     shared_future<R&> share() noexcept;
 186
 187     // retrieving the value
 188     R& get();
 189
 190     // functions to check state
 191     bool valid() const noexcept;
 192
 193     void wait() const;
 194     template <class Rep, class Period>
 195         future_status
 196         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 197     template <class Clock, class Duration>
 198         future_status
 199         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 200 };
 201
 202 template <>
 203 class future<void>
 204 {
 205 public:
 206     future() noexcept;
 207     future(future&&) noexcept;
 208     future(const future& rhs) = delete;
 209     ~future();
 210     future& operator=(const future& rhs) = delete;
 211     future& operator=(future&&) noexcept;
 212     shared_future<void> share() noexcept;
 213
 214     // retrieving the value
 215     void get();
 216
 217     // functions to check state
 218     bool valid() const noexcept;
 219
 220     void wait() const;
 221     template <class Rep, class Period>
 222         future_status
 223         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 224     template <class Clock, class Duration>
 225         future_status
 226         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 227 };
 228
 229 template <class R>
 230 class shared_future
 231 {
 232 public:
 233     shared_future() noexcept;
 234     shared_future(const shared_future& rhs);
 235     shared_future(future<R>&&) noexcept;
 236     shared_future(shared_future&& rhs) noexcept;
 237     ~shared_future();
 238     shared_future& operator=(const shared_future& rhs);
 239     shared_future& operator=(shared_future&& rhs) noexcept;
 240
 241     // retrieving the value
 242     const R& get() const;
 243
 244     // functions to check state
 245     bool valid() const noexcept;
 246
 247     void wait() const;
 248     template <class Rep, class Period>
 249         future_status
 250         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 251     template <class Clock, class Duration>
 252         future_status
 253         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 254 };
 255
 256 template <class R>
 257 class shared_future<R&>
 258 {
 259 public:
 260     shared_future() noexcept;
 261     shared_future(const shared_future& rhs);
 262     shared_future(future<R&>&&) noexcept;
 263     shared_future(shared_future&& rhs) noexcept;
 264     ~shared_future();
 265     shared_future& operator=(const shared_future& rhs);
 266     shared_future& operator=(shared_future&& rhs) noexcept;
 267
 268     // retrieving the value
 269     R& get() const;
 270
 271     // functions to check state
 272     bool valid() const noexcept;
 273
 274     void wait() const;
 275     template <class Rep, class Period>
 276         future_status
 277         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 278     template <class Clock, class Duration>
 279         future_status
 280         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 281 };
 282
 283 template <>
 284 class shared_future<void>
 285 {
 286 public:
 287     shared_future() noexcept;
 288     shared_future(const shared_future& rhs);
 289     shared_future(future<void>&&) noexcept;
 290     shared_future(shared_future&& rhs) noexcept;
 291     ~shared_future();
 292     shared_future& operator=(const shared_future& rhs);
 293     shared_future& operator=(shared_future&& rhs) noexcept;
 294
 295     // retrieving the value
 296     void get() const;
 297
 298     // functions to check state
 299     bool valid() const noexcept;
 300
 301     void wait() const;
 302     template <class Rep, class Period>
 303         future_status
 304         wait_for(const chrono::duration<Rep, Period>& rel_time) const;
 305     template <class Clock, class Duration>
 306         future_status
 307         wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 308 };
 309
 310 template <class F, class... Args>
 311   future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
 312   async(F&& f, Args&&... args);
 313
 314 template <class F, class... Args>
 315   future<typename result_of<typename decay<F>::type(typename decay<Args>::type...)>::type>
 316   async(launch policy, F&& f, Args&&... args);
 317
 318 template <class> class packaged_task; // undefined
 319
 320 template <class R, class... ArgTypes>
 321 class packaged_task<R(ArgTypes...)>
 322 {
 323 public:
 324     typedef R result_type; // extension
 325
 326     // construction and destruction
 327     packaged_task() noexcept;
 328     template <class F>
 329         explicit packaged_task(F&& f);
 330     template <class F, class Allocator>
 331         packaged_task(allocator_arg_t, const Allocator& a, F&& f);
 332     ~packaged_task();
 333
 334     // no copy
 335     packaged_task(const packaged_task&) = delete;
 336     packaged_task& operator=(const packaged_task&) = delete;
 337
 338     // move support
 339     packaged_task(packaged_task&& other) noexcept;
 340     packaged_task& operator=(packaged_task&& other) noexcept;
 341     void swap(packaged_task& other) noexcept;
 342
 343     bool valid() const noexcept;
 344
 345     // result retrieval
 346     future<R> get_future();
 347
 348     // execution
 349     void operator()(ArgTypes... );
 350     void make_ready_at_thread_exit(ArgTypes...);
 351
 352     void reset();
 353 };
 354
 355 template <class R>
 356   void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&) noexcept;
 357
 358 template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;
 359
 360 }  // std
 361
 362 */
 363
 364 #include <__assert> // all public C++ headers provide the assertion handler
 365 #include <__availability>
 366 #include <__chrono/duration.h>
 367 #include <__chrono/time_point.h>
 368 #include <__config>
 369 #include <__exception/exception_ptr.h>
 370 #include <__memory/addressof.h>
 371 #include <__memory/allocator.h>
 372 #include <__memory/allocator_arg_t.h>
 373 #include <__memory/allocator_destructor.h>
 374 #include <__memory/allocator_traits.h>
 375 #include <__memory/compressed_pair.h>
 376 #include <__memory/pointer_traits.h>
 377 #include <__memory/shared_ptr.h>
 378 #include <__memory/unique_ptr.h>
 379 #include <__memory/uses_allocator.h>
 380 #include <__system_error/error_category.h>
 381 #include <__system_error/error_code.h>
 382 #include <__system_error/error_condition.h>
 383 #include <__type_traits/aligned_storage.h>
 384 #include <__type_traits/alignment_of.h>
 385 #include <__type_traits/strip_signature.h>
 386 #include <__utility/auto_cast.h>
 387 #include <__utility/forward.h>
 388 #include <__utility/move.h>
 389 #include <mutex>
 390 #include <new>
 391 #include <stdexcept>
 392 #include <thread>
 393 #include <version>
 394
 395 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 396 #  pragma GCC system_header
 397 #endif
 398
 399 #ifdef _LIBCPP_HAS_NO_THREADS
 400 # error "<future> is not supported since libc++ has been configured without support for threads."
 401 #endif
 402
 403 _LIBCPP_BEGIN_NAMESPACE_STD
 404
 405 //enum class future_errc
 406 _LIBCPP_DECLARE_STRONG_ENUM(future_errc)
 407 {
 408     future_already_retrieved = 1,
 409     promise_already_satisfied,
 410     no_state,
 411     broken_promise
 412 };
 413 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
 414
 415 template <>
 416 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc> : public true_type {};
 417
 418 #ifdef _LIBCPP_CXX03_LANG
 419 template <>
 420 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type { };
 421 #endif
 422
 423 //enum class launch
 424 _LIBCPP_DECLARE_STRONG_ENUM(launch)
 425 {
 426     async = 1,
 427     deferred = 2,
 428     any = async | deferred
 429 };
 430 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)
 431
 432 #ifndef _LIBCPP_CXX03_LANG
 433
 434 typedef underlying_type<launch>::type __launch_underlying_type;
 435
 436 inline _LIBCPP_INLINE_VISIBILITY
 437 _LIBCPP_CONSTEXPR
 438 launch
 439 operator&(launch __x, launch __y)
 440 {
 441     return static_cast<launch>(static_cast<__launch_underlying_type>(__x) &
 442                                static_cast<__launch_underlying_type>(__y));
 443 }
 444
 445 inline _LIBCPP_INLINE_VISIBILITY
 446 _LIBCPP_CONSTEXPR
 447 launch
 448 operator|(launch __x, launch __y)
 449 {
 450     return static_cast<launch>(static_cast<__launch_underlying_type>(__x) |
 451                                static_cast<__launch_underlying_type>(__y));
 452 }
 453
 454 inline _LIBCPP_INLINE_VISIBILITY
 455 _LIBCPP_CONSTEXPR
 456 launch
 457 operator^(launch __x, launch __y)
 458 {
 459     return static_cast<launch>(static_cast<__launch_underlying_type>(__x) ^
 460                                static_cast<__launch_underlying_type>(__y));
 461 }
 462
 463 inline _LIBCPP_INLINE_VISIBILITY
 464 _LIBCPP_CONSTEXPR
 465 launch
 466 operator~(launch __x)
 467 {
 468     return static_cast<launch>(~static_cast<__launch_underlying_type>(__x) & 3);
 469 }
 470
 471 inline _LIBCPP_INLINE_VISIBILITY
 472 launch&
 473 operator&=(launch& __x, launch __y)
 474 {
 475     __x = __x & __y; return __x;
 476 }
 477
 478 inline _LIBCPP_INLINE_VISIBILITY
 479 launch&
 480 operator|=(launch& __x, launch __y)
 481 {
 482     __x = __x | __y; return __x;
 483 }
 484
 485 inline _LIBCPP_INLINE_VISIBILITY
 486 launch&
 487 operator^=(launch& __x, launch __y)
 488 {
 489     __x = __x ^ __y; return __x;
 490 }
 491
 492 #endif // !_LIBCPP_CXX03_LANG
 493
 494 //enum class future_status
 495 _LIBCPP_DECLARE_STRONG_ENUM(future_status)
 496 {
 497     ready,
 498     timeout,
 499     deferred
 500 };
 501 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)
 502
 503 _LIBCPP_EXPORTED_FROM_ABI const error_category& future_category() _NOEXCEPT;
 504
 505 inline _LIBCPP_INLINE_VISIBILITY
 506 error_code
 507 make_error_code(future_errc __e) _NOEXCEPT
 508 {
 509     return error_code(static_cast<int>(__e), future_category());
 510 }
 511
 512 inline _LIBCPP_INLINE_VISIBILITY
 513 error_condition
 514 make_error_condition(future_errc __e) _NOEXCEPT
 515 {
 516     return error_condition(static_cast<int>(__e), future_category());
 517 }
 518
 519 class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_FUTURE_ERROR future_error
 520     : public logic_error
 521 {
 522     error_code __ec_;
 523 public:
 524     future_error(error_code __ec);
 525
 526     _LIBCPP_INLINE_VISIBILITY
 527     const error_code& code() const _NOEXCEPT {return __ec_;}
 528
 529     _LIBCPP_HIDE_FROM_ABI future_error(const future_error&) _NOEXCEPT = default;
 530     ~future_error() _NOEXCEPT override;
 531 };
 532
 533 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
 534 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 535 _LIBCPP_AVAILABILITY_FUTURE_ERROR
 536 #endif
 537 void __throw_future_error(future_errc __ev)
 538 {
 539 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 540     throw future_error(make_error_code(__ev));
 541 #else
 542     (void)__ev;
 543     _LIBCPP_VERBOSE_ABORT("future_error was thrown in -fno-exceptions mode");
 544 #endif
 545 }
 546
 547 class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state
 548     : public __shared_count
 549 {
 550 protected:
 551     exception_ptr __exception_;
 552     mutable mutex __mut_;
 553     mutable condition_variable __cv_;
 554     unsigned __state_;
 555
 556     void __on_zero_shared() _NOEXCEPT override;
 557     void __sub_wait(unique_lock<mutex>& __lk);
 558 public:
 559     enum
 560     {
 561         __constructed = 1,
 562         __future_attached = 2,
 563         ready = 4,
 564         deferred = 8
 565     };
 566
 567     _LIBCPP_INLINE_VISIBILITY
 568     __assoc_sub_state() : __state_(0) {}
 569
 570     _LIBCPP_INLINE_VISIBILITY
 571     bool __has_value() const
 572         {return (__state_ & __constructed) || (__exception_ != nullptr);}
 573
 574     _LIBCPP_INLINE_VISIBILITY
 575     void __attach_future() {
 576         lock_guard<mutex> __lk(__mut_);
 577         bool __has_future_attached = (__state_ & __future_attached) != 0;
 578         if (__has_future_attached)
 579             __throw_future_error(future_errc::future_already_retrieved);
 580         this->__add_shared();
 581         __state_ |= __future_attached;
 582     }
 583
 584     _LIBCPP_INLINE_VISIBILITY
 585     void __set_deferred() {__state_ |= deferred;}
 586
 587     void __make_ready();
 588     _LIBCPP_INLINE_VISIBILITY
 589     bool __is_ready() const {return (__state_ & ready) != 0;}
 590
 591     void set_value();
 592     void set_value_at_thread_exit();
 593
 594     void set_exception(exception_ptr __p);
 595     void set_exception_at_thread_exit(exception_ptr __p);
 596
 597     void copy();
 598
 599     void wait();
 600     template <class _Rep, class _Period>
 601         future_status
 602         _LIBCPP_INLINE_VISIBILITY
 603         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;
 604     template <class _Clock, class _Duration>
 605         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 606         future_status
 607         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;
 608
 609     virtual void __execute();
 610 };
 611
 612 template <class _Clock, class _Duration>
 613 future_status
 614 __assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 615 {
 616     unique_lock<mutex> __lk(__mut_);
 617     if (__state_ & deferred)
 618         return future_status::deferred;
 619     while (!(__state_ & ready) && _Clock::now() < __abs_time)
 620         __cv_.wait_until(__lk, __abs_time);
 621     if (__state_ & ready)
 622         return future_status::ready;
 623     return future_status::timeout;
 624 }
 625
 626 template <class _Rep, class _Period>
 627 inline
 628 future_status
 629 __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 630 {
 631     return wait_until(chrono::steady_clock::now() + __rel_time);
 632 }
 633
 634 template <class _Rp>
 635 class _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_HIDDEN __assoc_state
 636     : public __assoc_sub_state
 637 {
 638     typedef __assoc_sub_state base;
 639 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 640     typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;
 641 _LIBCPP_SUPPRESS_DEPRECATED_POP
 642 protected:
 643     _Up __value_;
 644
 645     _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 646 public:
 647
 648     template <class _Arg>
 649     _LIBCPP_HIDE_FROM_ABI void set_value(_Arg&& __arg);
 650
 651     template <class _Arg>
 652     _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Arg&& __arg);
 653
 654     _LIBCPP_HIDE_FROM_ABI _Rp move();
 655     _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<_Rp> copy();
 656 };
 657
 658 template <class _Rp>
 659 void
 660 __assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT
 661 {
 662     if (this->__state_ & base::__constructed)
 663         reinterpret_cast<_Rp*>(&__value_)->~_Rp();
 664     delete this;
 665 }
 666
 667 template <class _Rp>
 668 template <class _Arg>
 669 _LIBCPP_AVAILABILITY_FUTURE
 670 void
 671 __assoc_state<_Rp>::set_value(_Arg&& __arg)
 672 {
 673     unique_lock<mutex> __lk(this->__mut_);
 674     if (this->__has_value())
 675         __throw_future_error(future_errc::promise_already_satisfied);
 676     ::new ((void*)&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
 677     this->__state_ |= base::__constructed | base::ready;
 678     __cv_.notify_all();
 679 }
 680
 681 template <class _Rp>
 682 template <class _Arg>
 683 void
 684 __assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg)
 685 {
 686     unique_lock<mutex> __lk(this->__mut_);
 687     if (this->__has_value())
 688         __throw_future_error(future_errc::promise_already_satisfied);
 689     ::new ((void*)&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
 690     this->__state_ |= base::__constructed;
 691     __thread_local_data()->__make_ready_at_thread_exit(this);
 692 }
 693
 694 template <class _Rp>
 695 _Rp
 696 __assoc_state<_Rp>::move()
 697 {
 698     unique_lock<mutex> __lk(this->__mut_);
 699     this->__sub_wait(__lk);
 700     if (this->__exception_ != nullptr)
 701         std::rethrow_exception(this->__exception_);
 702     return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));
 703 }
 704
 705 template <class _Rp>
 706 __add_lvalue_reference_t<_Rp>
 707 __assoc_state<_Rp>::copy()
 708 {
 709     unique_lock<mutex> __lk(this->__mut_);
 710     this->__sub_wait(__lk);
 711     if (this->__exception_ != nullptr)
 712         std::rethrow_exception(this->__exception_);
 713     return *reinterpret_cast<_Rp*>(&__value_);
 714 }
 715
 716 template <class _Rp>
 717 class _LIBCPP_AVAILABILITY_FUTURE __assoc_state<_Rp&>
 718     : public __assoc_sub_state
 719 {
 720     typedef __assoc_sub_state base;
 721     typedef _Rp* _Up;
 722 protected:
 723     _Up __value_;
 724
 725     _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 726 public:
 727
 728     _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __arg);
 729     _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp& __arg);
 730
 731     _LIBCPP_HIDE_FROM_ABI _Rp& copy();
 732 };
 733
 734 template <class _Rp>
 735 void
 736 __assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT
 737 {
 738     delete this;
 739 }
 740
 741 template <class _Rp>
 742 void
 743 __assoc_state<_Rp&>::set_value(_Rp& __arg)
 744 {
 745     unique_lock<mutex> __lk(this->__mut_);
 746     if (this->__has_value())
 747         __throw_future_error(future_errc::promise_already_satisfied);
 748     __value_ = _VSTD::addressof(__arg);
 749     this->__state_ |= base::__constructed | base::ready;
 750     __cv_.notify_all();
 751 }
 752
 753 template <class _Rp>
 754 void
 755 __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg)
 756 {
 757     unique_lock<mutex> __lk(this->__mut_);
 758     if (this->__has_value())
 759         __throw_future_error(future_errc::promise_already_satisfied);
 760     __value_ = _VSTD::addressof(__arg);
 761     this->__state_ |= base::__constructed;
 762     __thread_local_data()->__make_ready_at_thread_exit(this);
 763 }
 764
 765 template <class _Rp>
 766 _Rp&
 767 __assoc_state<_Rp&>::copy()
 768 {
 769     unique_lock<mutex> __lk(this->__mut_);
 770     this->__sub_wait(__lk);
 771     if (this->__exception_ != nullptr)
 772         std::rethrow_exception(this->__exception_);
 773     return *__value_;
 774 }
 775
 776 template <class _Rp, class _Alloc>
 777 class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc
 778     : public __assoc_state<_Rp>
 779 {
 780     typedef __assoc_state<_Rp> base;
 781     _Alloc __alloc_;
 782
 783     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;
 784 public:
 785     _LIBCPP_INLINE_VISIBILITY
 786     explicit __assoc_state_alloc(const _Alloc& __a)
 787         : __alloc_(__a) {}
 788 };
 789
 790 template <class _Rp, class _Alloc>
 791 void
 792 __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT
 793 {
 794     if (this->__state_ & base::__constructed)
 795         reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp();
 796     typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
 797     typedef allocator_traits<_Al> _ATraits;
 798     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
 799     _Al __a(__alloc_);
 800     this->~__assoc_state_alloc();
 801     __a.deallocate(_PTraits::pointer_to(*this), 1);
 802 }
 803
 804 template <class _Rp, class _Alloc>
 805 class _LIBCPP_AVAILABILITY_FUTURE __assoc_state_alloc<_Rp&, _Alloc>
 806     : public __assoc_state<_Rp&>
 807 {
 808     typedef __assoc_state<_Rp&> base;
 809     _Alloc __alloc_;
 810
 811     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;
 812 public:
 813     _LIBCPP_INLINE_VISIBILITY
 814     explicit __assoc_state_alloc(const _Alloc& __a)
 815         : __alloc_(__a) {}
 816 };
 817
 818 template <class _Rp, class _Alloc>
 819 void
 820 __assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT
 821 {
 822     typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
 823     typedef allocator_traits<_Al> _ATraits;
 824     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
 825     _Al __a(__alloc_);
 826     this->~__assoc_state_alloc();
 827     __a.deallocate(_PTraits::pointer_to(*this), 1);
 828 }
 829
 830 template <class _Alloc>
 831 class _LIBCPP_AVAILABILITY_FUTURE __assoc_sub_state_alloc
 832     : public __assoc_sub_state
 833 {
 834     typedef __assoc_sub_state base;
 835     _Alloc __alloc_;
 836
 837     _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 838 public:
 839     _LIBCPP_INLINE_VISIBILITY
 840     explicit __assoc_sub_state_alloc(const _Alloc& __a)
 841         : __alloc_(__a) {}
 842 };
 843
 844 template <class _Alloc>
 845 void
 846 __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT
 847 {
 848     typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al;
 849     typedef allocator_traits<_Al> _ATraits;
 850     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
 851     _Al __a(__alloc_);
 852     this->~__assoc_sub_state_alloc();
 853     __a.deallocate(_PTraits::pointer_to(*this), 1);
 854 }
 855
 856 template <class _Rp, class _Fp>
 857 class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state
 858     : public __assoc_state<_Rp>
 859 {
 860     typedef __assoc_state<_Rp> base;
 861
 862     _Fp __func_;
 863
 864 public:
 865     _LIBCPP_INLINE_VISIBILITY
 866     explicit __deferred_assoc_state(_Fp&& __f);
 867
 868     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute();
 869 };
 870
 871 template <class _Rp, class _Fp>
 872 inline
 873 __deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f)
 874     : __func_(_VSTD::forward<_Fp>(__f))
 875 {
 876     this->__set_deferred();
 877 }
 878
 879 template <class _Rp, class _Fp>
 880 void
 881 __deferred_assoc_state<_Rp, _Fp>::__execute()
 882 {
 883 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 884     try
 885     {
 886 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 887         this->set_value(__func_());
 888 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 889     }
 890     catch (...)
 891     {
 892         this->set_exception(current_exception());
 893     }
 894 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 895 }
 896
 897 template <class _Fp>
 898 class _LIBCPP_AVAILABILITY_FUTURE __deferred_assoc_state<void, _Fp>
 899     : public __assoc_sub_state
 900 {
 901     typedef __assoc_sub_state base;
 902
 903     _Fp __func_;
 904
 905 public:
 906     _LIBCPP_INLINE_VISIBILITY
 907     explicit __deferred_assoc_state(_Fp&& __f);
 908
 909     _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override;
 910 };
 911
 912 template <class _Fp>
 913 inline
 914 __deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)
 915     : __func_(_VSTD::forward<_Fp>(__f))
 916 {
 917     this->__set_deferred();
 918 }
 919
 920 template <class _Fp>
 921 void
 922 __deferred_assoc_state<void, _Fp>::__execute()
 923 {
 924 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 925     try
 926     {
 927 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 928         __func_();
 929         this->set_value();
 930 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 931     }
 932     catch (...)
 933     {
 934         this->set_exception(current_exception());
 935     }
 936 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 937 }
 938
 939 template <class _Rp, class _Fp>
 940 class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state
 941     : public __assoc_state<_Rp>
 942 {
 943     typedef __assoc_state<_Rp> base;
 944
 945     _Fp __func_;
 946
 947     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;
 948 public:
 949     _LIBCPP_INLINE_VISIBILITY
 950     explicit __async_assoc_state(_Fp&& __f);
 951
 952     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute();
 953 };
 954
 955 template <class _Rp, class _Fp>
 956 inline
 957 __async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)
 958     : __func_(_VSTD::forward<_Fp>(__f))
 959 {
 960 }
 961
 962 template <class _Rp, class _Fp>
 963 void
 964 __async_assoc_state<_Rp, _Fp>::__execute()
 965 {
 966 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 967     try
 968     {
 969 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 970         this->set_value(__func_());
 971 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
 972     }
 973     catch (...)
 974     {
 975         this->set_exception(current_exception());
 976     }
 977 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
 978 }
 979
 980 template <class _Rp, class _Fp>
 981 void
 982 __async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT
 983 {
 984     this->wait();
 985     base::__on_zero_shared();
 986 }
 987
 988 template <class _Fp>
 989 class _LIBCPP_AVAILABILITY_FUTURE __async_assoc_state<void, _Fp>
 990     : public __assoc_sub_state
 991 {
 992     typedef __assoc_sub_state base;
 993
 994     _Fp __func_;
 995
 996     _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 997 public:
 998     _LIBCPP_INLINE_VISIBILITY
 999     explicit __async_assoc_state(_Fp&& __f);
1000
1001     _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override;
1002 };
1003
1004 template <class _Fp>
1005 inline
1006 __async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
1007     : __func_(_VSTD::forward<_Fp>(__f))
1008 {
1009 }
1010
1011 template <class _Fp>
1012 void
1013 __async_assoc_state<void, _Fp>::__execute()
1014 {
1015 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
1016     try
1017     {
1018 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
1019         __func_();
1020         this->set_value();
1021 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
1022     }
1023     catch (...)
1024     {
1025         this->set_exception(current_exception());
1026     }
1027 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
1028 }
1029
1030 template <class _Fp>
1031 void
1032 __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT
1033 {
1034     this->wait();
1035     base::__on_zero_shared();
1036 }
1037
1038 template <class _Rp> class _LIBCPP_TEMPLATE_VIS promise;
1039 template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future;
1040
1041 // future
1042
1043 template <class _Rp> class _LIBCPP_TEMPLATE_VIS future;
1044
1045 template <class _Rp, class _Fp>
1046 _LIBCPP_INLINE_VISIBILITY future<_Rp>
1047 __make_deferred_assoc_state(_Fp&& __f);
1048
1049 template <class _Rp, class _Fp>
1050 _LIBCPP_INLINE_VISIBILITY future<_Rp>
1051 __make_async_assoc_state(_Fp&& __f);
1052
1053 template <class _Rp>
1054 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future
1055 {
1056     __assoc_state<_Rp>* __state_;
1057
1058     explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp>* __state);
1059
1060     template <class> friend class promise;
1061     template <class> friend class shared_future;
1062
1063     template <class _R1, class _Fp>
1064         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
1065     template <class _R1, class _Fp>
1066         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
1067
1068 public:
1069     _LIBCPP_INLINE_VISIBILITY
1070     future() _NOEXCEPT : __state_(nullptr) {}
1071     _LIBCPP_INLINE_VISIBILITY
1072     future(future&& __rhs) _NOEXCEPT
1073         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1074     future(const future&) = delete;
1075     future& operator=(const future&) = delete;
1076     _LIBCPP_INLINE_VISIBILITY
1077     future& operator=(future&& __rhs) _NOEXCEPT
1078         {
1079             future(_VSTD::move(__rhs)).swap(*this);
1080             return *this;
1081         }
1082
1083     _LIBCPP_HIDE_FROM_ABI ~future();
1084     _LIBCPP_INLINE_VISIBILITY
1085     shared_future<_Rp> share() _NOEXCEPT;
1086
1087     // retrieving the value
1088     _LIBCPP_HIDE_FROM_ABI _Rp get();
1089
1090     _LIBCPP_INLINE_VISIBILITY
1091     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1092
1093     // functions to check state
1094     _LIBCPP_INLINE_VISIBILITY
1095     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
1096
1097     _LIBCPP_INLINE_VISIBILITY
1098     void wait() const {__state_->wait();}
1099     template <class _Rep, class _Period>
1100         _LIBCPP_INLINE_VISIBILITY
1101         future_status
1102         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
1103             {return __state_->wait_for(__rel_time);}
1104     template <class _Clock, class _Duration>
1105         _LIBCPP_INLINE_VISIBILITY
1106         future_status
1107         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
1108             {return __state_->wait_until(__abs_time);}
1109 };
1110
1111 template <class _Rp>
1112 future<_Rp>::future(__assoc_state<_Rp>* __state)
1113     : __state_(__state)
1114 {
1115     __state_->__attach_future();
1116 }
1117
1118 struct __release_shared_count
1119 {
1120     _LIBCPP_HIDE_FROM_ABI void operator()(__shared_count* __p) {__p->__release_shared();}
1121 };
1122
1123 template <class _Rp>
1124 future<_Rp>::~future()
1125 {
1126     if (__state_)
1127         __state_->__release_shared();
1128 }
1129
1130 template <class _Rp>
1131 _Rp
1132 future<_Rp>::get()
1133 {
1134     unique_ptr<__shared_count, __release_shared_count> __guard(__state_);
1135     __assoc_state<_Rp>* __s = __state_;
1136     __state_ = nullptr;
1137     return __s->move();
1138 }
1139
1140 template <class _Rp>
1141 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE future<_Rp&>
1142 {
1143     __assoc_state<_Rp&>* __state_;
1144
1145     explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp&>* __state);
1146
1147     template <class> friend class promise;
1148     template <class> friend class shared_future;
1149
1150     template <class _R1, class _Fp>
1151         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
1152     template <class _R1, class _Fp>
1153         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
1154
1155 public:
1156     _LIBCPP_INLINE_VISIBILITY
1157     future() _NOEXCEPT : __state_(nullptr) {}
1158     _LIBCPP_INLINE_VISIBILITY
1159     future(future&& __rhs) _NOEXCEPT
1160         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1161     future(const future&) = delete;
1162     future& operator=(const future&) = delete;
1163     _LIBCPP_INLINE_VISIBILITY
1164     future& operator=(future&& __rhs) _NOEXCEPT
1165         {
1166             future(_VSTD::move(__rhs)).swap(*this);
1167             return *this;
1168         }
1169
1170     _LIBCPP_HIDE_FROM_ABI ~future();
1171     _LIBCPP_INLINE_VISIBILITY
1172     shared_future<_Rp&> share() _NOEXCEPT;
1173
1174     // retrieving the value
1175     _LIBCPP_HIDE_FROM_ABI _Rp& get();
1176
1177     _LIBCPP_INLINE_VISIBILITY
1178     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1179
1180     // functions to check state
1181     _LIBCPP_INLINE_VISIBILITY
1182     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
1183
1184     _LIBCPP_INLINE_VISIBILITY
1185     void wait() const {__state_->wait();}
1186     template <class _Rep, class _Period>
1187         _LIBCPP_INLINE_VISIBILITY
1188         future_status
1189         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
1190             {return __state_->wait_for(__rel_time);}
1191     template <class _Clock, class _Duration>
1192         _LIBCPP_INLINE_VISIBILITY
1193         future_status
1194         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
1195             {return __state_->wait_until(__abs_time);}
1196 };
1197
1198 template <class _Rp>
1199 future<_Rp&>::future(__assoc_state<_Rp&>* __state)
1200     : __state_(__state)
1201 {
1202     __state_->__attach_future();
1203 }
1204
1205 template <class _Rp>
1206 future<_Rp&>::~future()
1207 {
1208     if (__state_)
1209         __state_->__release_shared();
1210 }
1211
1212 template <class _Rp>
1213 _Rp&
1214 future<_Rp&>::get()
1215 {
1216     unique_ptr<__shared_count, __release_shared_count> __guard(__state_);
1217     __assoc_state<_Rp&>* __s = __state_;
1218     __state_ = nullptr;
1219     return __s->copy();
1220 }
1221
1222 template <>
1223 class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_FUTURE future<void>
1224 {
1225     __assoc_sub_state* __state_;
1226
1227     explicit future(__assoc_sub_state* __state);
1228
1229     template <class> friend class promise;
1230     template <class> friend class shared_future;
1231
1232     template <class _R1, class _Fp>
1233         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
1234     template <class _R1, class _Fp>
1235         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
1236
1237 public:
1238     _LIBCPP_INLINE_VISIBILITY
1239     future() _NOEXCEPT : __state_(nullptr) {}
1240     _LIBCPP_INLINE_VISIBILITY
1241     future(future&& __rhs) _NOEXCEPT
1242         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1243     future(const future&) = delete;
1244     future& operator=(const future&) = delete;
1245     _LIBCPP_INLINE_VISIBILITY
1246     future& operator=(future&& __rhs) _NOEXCEPT
1247         {
1248             future(_VSTD::move(__rhs)).swap(*this);
1249             return *this;
1250         }
1251
1252     ~future();
1253     _LIBCPP_INLINE_VISIBILITY
1254     shared_future<void> share() _NOEXCEPT;
1255
1256     // retrieving the value
1257     void get();
1258
1259     _LIBCPP_INLINE_VISIBILITY
1260     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1261
1262     // functions to check state
1263     _LIBCPP_INLINE_VISIBILITY
1264     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
1265
1266     _LIBCPP_INLINE_VISIBILITY
1267     void wait() const {__state_->wait();}
1268     template <class _Rep, class _Period>
1269         _LIBCPP_INLINE_VISIBILITY
1270         future_status
1271         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
1272             {return __state_->wait_for(__rel_time);}
1273     template <class _Clock, class _Duration>
1274         _LIBCPP_INLINE_VISIBILITY
1275         future_status
1276         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
1277             {return __state_->wait_until(__abs_time);}
1278 };
1279
1280 template <class _Rp>
1281 inline _LIBCPP_INLINE_VISIBILITY
1282 void
1283 swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT
1284 {
1285     __x.swap(__y);
1286 }
1287
1288 // promise<R>
1289
1290 template <class _Callable> class packaged_task;
1291
1292 template <class _Rp>
1293 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise
1294 {
1295     __assoc_state<_Rp>* __state_;
1296
1297     _LIBCPP_INLINE_VISIBILITY
1298     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
1299
1300     template <class> friend class packaged_task;
1301 public:
1302     _LIBCPP_HIDE_FROM_ABI promise();
1303     template <class _Alloc>
1304     _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Alloc& __a);
1305     _LIBCPP_INLINE_VISIBILITY
1306     promise(promise&& __rhs) _NOEXCEPT
1307         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1308     promise(const promise& __rhs) = delete;
1309     _LIBCPP_HIDE_FROM_ABI ~promise();
1310
1311     // assignment
1312     _LIBCPP_INLINE_VISIBILITY
1313     promise& operator=(promise&& __rhs) _NOEXCEPT
1314         {
1315             promise(_VSTD::move(__rhs)).swap(*this);
1316             return *this;
1317         }
1318     promise& operator=(const promise& __rhs) = delete;
1319
1320     _LIBCPP_INLINE_VISIBILITY
1321     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1322
1323     // retrieving the result
1324     _LIBCPP_HIDE_FROM_ABI future<_Rp> get_future();
1325
1326     // setting the result
1327     _LIBCPP_HIDE_FROM_ABI void set_value(const _Rp& __r);
1328     _LIBCPP_HIDE_FROM_ABI void set_value(_Rp&& __r);
1329     _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p);
1330
1331     // setting the result with deferred notification
1332     _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(const _Rp& __r);
1333     _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&& __r);
1334     _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p);
1335 };
1336
1337 template <class _Rp>
1338 promise<_Rp>::promise()
1339     : __state_(new __assoc_state<_Rp>)
1340 {
1341 }
1342
1343 template <class _Rp>
1344 template <class _Alloc>
1345 promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0)
1346 {
1347     typedef __assoc_state_alloc<_Rp, _Alloc> _State;
1348     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
1349     typedef __allocator_destructor<_A2> _D2;
1350     _A2 __a(__a0);
1351     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
1352     ::new ((void*)_VSTD::addressof(*__hold.get())) _State(__a0);
1353     __state_ = _VSTD::addressof(*__hold.release());
1354 }
1355
1356 template <class _Rp>
1357 promise<_Rp>::~promise()
1358 {
1359     if (__state_)
1360     {
1361         if (!__state_->__has_value() && __state_->use_count() > 1)
1362             __state_->set_exception(make_exception_ptr(
1363                       future_error(make_error_code(future_errc::broken_promise))
1364                                                       ));
1365         __state_->__release_shared();
1366     }
1367 }
1368
1369 template <class _Rp>
1370 future<_Rp>
1371 promise<_Rp>::get_future()
1372 {
1373     if (__state_ == nullptr)
1374         __throw_future_error(future_errc::no_state);
1375     return future<_Rp>(__state_);
1376 }
1377
1378 template <class _Rp>
1379 void
1380 promise<_Rp>::set_value(const _Rp& __r)
1381 {
1382     if (__state_ == nullptr)
1383         __throw_future_error(future_errc::no_state);
1384     __state_->set_value(__r);
1385 }
1386
1387 template <class _Rp>
1388 void
1389 promise<_Rp>::set_value(_Rp&& __r)
1390 {
1391     if (__state_ == nullptr)
1392         __throw_future_error(future_errc::no_state);
1393     __state_->set_value(_VSTD::move(__r));
1394 }
1395
1396 template <class _Rp>
1397 void
1398 promise<_Rp>::set_exception(exception_ptr __p)
1399 {
1400     _LIBCPP_ASSERT_UNCATEGORIZED( __p != nullptr, "promise::set_exception: received nullptr" );
1401     if (__state_ == nullptr)
1402         __throw_future_error(future_errc::no_state);
1403     __state_->set_exception(__p);
1404 }
1405
1406 template <class _Rp>
1407 void
1408 promise<_Rp>::set_value_at_thread_exit(const _Rp& __r)
1409 {
1410     if (__state_ == nullptr)
1411         __throw_future_error(future_errc::no_state);
1412     __state_->set_value_at_thread_exit(__r);
1413 }
1414
1415 template <class _Rp>
1416 void
1417 promise<_Rp>::set_value_at_thread_exit(_Rp&& __r)
1418 {
1419     if (__state_ == nullptr)
1420         __throw_future_error(future_errc::no_state);
1421     __state_->set_value_at_thread_exit(_VSTD::move(__r));
1422 }
1423
1424 template <class _Rp>
1425 void
1426 promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
1427 {
1428     _LIBCPP_ASSERT_UNCATEGORIZED( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
1429     if (__state_ == nullptr)
1430         __throw_future_error(future_errc::no_state);
1431     __state_->set_exception_at_thread_exit(__p);
1432 }
1433
1434 // promise<R&>
1435
1436 template <class _Rp>
1437 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE promise<_Rp&>
1438 {
1439     __assoc_state<_Rp&>* __state_;
1440
1441     _LIBCPP_INLINE_VISIBILITY
1442     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
1443
1444     template <class> friend class packaged_task;
1445
1446 public:
1447     _LIBCPP_HIDE_FROM_ABI promise();
1448     template <class _Allocator>
1449     _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Allocator& __a);
1450     _LIBCPP_INLINE_VISIBILITY
1451     promise(promise&& __rhs) _NOEXCEPT
1452         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1453     promise(const promise& __rhs) = delete;
1454     _LIBCPP_HIDE_FROM_ABI ~promise();
1455
1456     // assignment
1457     _LIBCPP_INLINE_VISIBILITY
1458     promise& operator=(promise&& __rhs) _NOEXCEPT
1459         {
1460             promise(_VSTD::move(__rhs)).swap(*this);
1461             return *this;
1462         }
1463     promise& operator=(const promise& __rhs) = delete;
1464
1465     _LIBCPP_INLINE_VISIBILITY
1466     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1467
1468     // retrieving the result
1469     _LIBCPP_HIDE_FROM_ABI future<_Rp&> get_future();
1470
1471     // setting the result
1472     _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __r);
1473     _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p);
1474
1475     // setting the result with deferred notification
1476     _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&);
1477     _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p);
1478 };
1479
1480 template <class _Rp>
1481 promise<_Rp&>::promise()
1482     : __state_(new __assoc_state<_Rp&>)
1483 {
1484 }
1485
1486 template <class _Rp>
1487 template <class _Alloc>
1488 promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0)
1489 {
1490     typedef __assoc_state_alloc<_Rp&, _Alloc> _State;
1491     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
1492     typedef __allocator_destructor<_A2> _D2;
1493     _A2 __a(__a0);
1494     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
1495     ::new ((void*)_VSTD::addressof(*__hold.get())) _State(__a0);
1496     __state_ = _VSTD::addressof(*__hold.release());
1497 }
1498
1499 template <class _Rp>
1500 promise<_Rp&>::~promise()
1501 {
1502     if (__state_)
1503     {
1504         if (!__state_->__has_value() && __state_->use_count() > 1)
1505             __state_->set_exception(make_exception_ptr(
1506                       future_error(make_error_code(future_errc::broken_promise))
1507                                                       ));
1508         __state_->__release_shared();
1509     }
1510 }
1511
1512 template <class _Rp>
1513 future<_Rp&>
1514 promise<_Rp&>::get_future()
1515 {
1516     if (__state_ == nullptr)
1517         __throw_future_error(future_errc::no_state);
1518     return future<_Rp&>(__state_);
1519 }
1520
1521 template <class _Rp>
1522 void
1523 promise<_Rp&>::set_value(_Rp& __r)
1524 {
1525     if (__state_ == nullptr)
1526         __throw_future_error(future_errc::no_state);
1527     __state_->set_value(__r);
1528 }
1529
1530 template <class _Rp>
1531 void
1532 promise<_Rp&>::set_exception(exception_ptr __p)
1533 {
1534     _LIBCPP_ASSERT_UNCATEGORIZED( __p != nullptr, "promise::set_exception: received nullptr" );
1535     if (__state_ == nullptr)
1536         __throw_future_error(future_errc::no_state);
1537     __state_->set_exception(__p);
1538 }
1539
1540 template <class _Rp>
1541 void
1542 promise<_Rp&>::set_value_at_thread_exit(_Rp& __r)
1543 {
1544     if (__state_ == nullptr)
1545         __throw_future_error(future_errc::no_state);
1546     __state_->set_value_at_thread_exit(__r);
1547 }
1548
1549 template <class _Rp>
1550 void
1551 promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p)
1552 {
1553     _LIBCPP_ASSERT_UNCATEGORIZED( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
1554     if (__state_ == nullptr)
1555         __throw_future_error(future_errc::no_state);
1556     __state_->set_exception_at_thread_exit(__p);
1557 }
1558
1559 // promise<void>
1560
1561 template <>
1562 class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_FUTURE promise<void>
1563 {
1564     __assoc_sub_state* __state_;
1565
1566     _LIBCPP_INLINE_VISIBILITY
1567     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
1568
1569     template <class> friend class packaged_task;
1570
1571 public:
1572     promise();
1573     template <class _Allocator>
1574         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1575         promise(allocator_arg_t, const _Allocator& __a);
1576     _LIBCPP_INLINE_VISIBILITY
1577     promise(promise&& __rhs) _NOEXCEPT
1578         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1579     promise(const promise& __rhs) = delete;
1580     ~promise();
1581
1582     // assignment
1583     _LIBCPP_INLINE_VISIBILITY
1584     promise& operator=(promise&& __rhs) _NOEXCEPT
1585         {
1586             promise(_VSTD::move(__rhs)).swap(*this);
1587             return *this;
1588         }
1589     promise& operator=(const promise& __rhs) = delete;
1590
1591     _LIBCPP_INLINE_VISIBILITY
1592     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1593
1594     // retrieving the result
1595     future<void> get_future();
1596
1597     // setting the result
1598     void set_value();
1599     void set_exception(exception_ptr __p);
1600
1601     // setting the result with deferred notification
1602     void set_value_at_thread_exit();
1603     void set_exception_at_thread_exit(exception_ptr __p);
1604 };
1605
1606 template <class _Alloc>
1607 promise<void>::promise(allocator_arg_t, const _Alloc& __a0)
1608 {
1609     typedef __assoc_sub_state_alloc<_Alloc> _State;
1610     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
1611     typedef __allocator_destructor<_A2> _D2;
1612     _A2 __a(__a0);
1613     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
1614     ::new ((void*)_VSTD::addressof(*__hold.get())) _State(__a0);
1615     __state_ = _VSTD::addressof(*__hold.release());
1616 }
1617
1618 template <class _Rp>
1619 inline _LIBCPP_INLINE_VISIBILITY
1620 void
1621 swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT
1622 {
1623     __x.swap(__y);
1624 }
1625
1626 template <class _Rp, class _Alloc>
1627     struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc>
1628         : public true_type {};
1629
1630 // packaged_task
1631
1632 template<class _Fp> class __packaged_task_base;
1633
1634 template<class _Rp, class ..._ArgTypes>
1635 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_base<_Rp(_ArgTypes...)>
1636 {
1637     __packaged_task_base(const __packaged_task_base&);
1638     __packaged_task_base& operator=(const __packaged_task_base&);
1639 public:
1640     _LIBCPP_INLINE_VISIBILITY
1641     __packaged_task_base() {}
1642     _LIBCPP_HIDE_FROM_ABI_VIRTUAL
1643     virtual ~__packaged_task_base() {}
1644     virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
1645     virtual void destroy() = 0;
1646     virtual void destroy_deallocate() = 0;
1647     virtual _Rp operator()(_ArgTypes&& ...) = 0;
1648 };
1649
1650 template<class _FD, class _Alloc, class _FB> class __packaged_task_func;
1651
1652 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1653 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>
1654     : public  __packaged_task_base<_Rp(_ArgTypes...)>
1655 {
1656     __compressed_pair<_Fp, _Alloc> __f_;
1657 public:
1658     _LIBCPP_INLINE_VISIBILITY
1659     explicit __packaged_task_func(const _Fp& __f) : __f_(__f, __default_init_tag()) {}
1660     _LIBCPP_INLINE_VISIBILITY
1661     explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f), __default_init_tag()) {}
1662     _LIBCPP_INLINE_VISIBILITY
1663     __packaged_task_func(const _Fp& __f, const _Alloc& __a)
1664         : __f_(__f, __a) {}
1665     _LIBCPP_INLINE_VISIBILITY
1666     __packaged_task_func(_Fp&& __f, const _Alloc& __a)
1667         : __f_(_VSTD::move(__f), __a) {}
1668     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;
1669     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy();
1670     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy_deallocate();
1671     _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual _Rp operator()(_ArgTypes&& ... __args);
1672 };
1673
1674 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1675 void
1676 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
1677                               __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT
1678 {
1679     ::new ((void*)__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
1680 }
1681
1682 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1683 void
1684 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy()
1685 {
1686     __f_.~__compressed_pair<_Fp, _Alloc>();
1687 }
1688
1689 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1690 void
1691 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate()
1692 {
1693     typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap;
1694     typedef allocator_traits<_Ap> _ATraits;
1695     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
1696     _Ap __a(__f_.second());
1697     __f_.~__compressed_pair<_Fp, _Alloc>();
1698     __a.deallocate(_PTraits::pointer_to(*this), 1);
1699 }
1700
1701 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1702 _Rp
1703 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
1704 {
1705     return _VSTD::__invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
1706 }
1707
1708 template <class _Callable> class __packaged_task_function;
1709
1710 template<class _Rp, class ..._ArgTypes>
1711 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_function<_Rp(_ArgTypes...)>
1712 {
1713     typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
1714
1715     _LIBCPP_INLINE_VISIBILITY _LIBCPP_NO_CFI
1716     __base* __get_buf() { return (__base*)&__buf_; }
1717
1718     _LIBCPP_SUPPRESS_DEPRECATED_PUSH
1719     typename aligned_storage<3*sizeof(void*)>::type __buf_;
1720     _LIBCPP_SUPPRESS_DEPRECATED_POP
1721     __base* __f_;
1722
1723 public:
1724     typedef _Rp result_type;
1725
1726     // construct/copy/destroy:
1727     _LIBCPP_INLINE_VISIBILITY
1728     __packaged_task_function() _NOEXCEPT : __f_(nullptr) {}
1729     template<class _Fp>
1730     _LIBCPP_HIDE_FROM_ABI __packaged_task_function(_Fp&& __f);
1731     template<class _Fp, class _Alloc>
1732     _LIBCPP_HIDE_FROM_ABI __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f);
1733
1734     _LIBCPP_HIDE_FROM_ABI __packaged_task_function(__packaged_task_function&&) _NOEXCEPT;
1735     _LIBCPP_HIDE_FROM_ABI __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT;
1736
1737     __packaged_task_function(const __packaged_task_function&) =  delete;
1738     __packaged_task_function& operator=(const __packaged_task_function&) =  delete;
1739
1740     _LIBCPP_HIDE_FROM_ABI ~__packaged_task_function();
1741
1742     _LIBCPP_HIDE_FROM_ABI void swap(__packaged_task_function&) _NOEXCEPT;
1743
1744     _LIBCPP_INLINE_VISIBILITY
1745     _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes...) const;
1746 };
1747
1748 template<class _Rp, class ..._ArgTypes>
1749 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT
1750 {
1751     if (__f.__f_ == nullptr)
1752         __f_ = nullptr;
1753     else if (__f.__f_ == __f.__get_buf())
1754     {
1755         __f.__f_->__move_to(__get_buf());
1756         __f_ = (__base*)&__buf_;
1757     }
1758     else
1759     {
1760         __f_ = __f.__f_;
1761         __f.__f_ = nullptr;
1762     }
1763 }
1764
1765 template<class _Rp, class ..._ArgTypes>
1766 template <class _Fp>
1767 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f)
1768     : __f_(nullptr)
1769 {
1770     typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR;
1771     typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;
1772     if (sizeof(_FF) <= sizeof(__buf_))
1773     {
1774         ::new ((void*)&__buf_) _FF(_VSTD::forward<_Fp>(__f));
1775         __f_ = (__base*)&__buf_;
1776     }
1777     else
1778     {
1779         typedef allocator<_FF> _Ap;
1780         _Ap __a;
1781         typedef __allocator_destructor<_Ap> _Dp;
1782         unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1783         ::new ((void*)__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a));
1784         __f_ = __hold.release();
1785     }
1786 }
1787
1788 template<class _Rp, class ..._ArgTypes>
1789 template <class _Fp, class _Alloc>
1790 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(
1791                                   allocator_arg_t, const _Alloc& __a0, _Fp&& __f)
1792     : __f_(nullptr)
1793 {
1794     typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR;
1795     typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;
1796     if (sizeof(_FF) <= sizeof(__buf_))
1797     {
1798         __f_ = (__base*)&__buf_;
1799         ::new ((void*)__f_) _FF(_VSTD::forward<_Fp>(__f));
1800     }
1801     else
1802     {
1803         typedef typename __allocator_traits_rebind<_Alloc, _FF>::type _Ap;
1804         _Ap __a(__a0);
1805         typedef __allocator_destructor<_Ap> _Dp;
1806         unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1807         ::new ((void*)_VSTD::addressof(*__hold.get()))
1808             _FF(_VSTD::forward<_Fp>(__f), _Alloc(__a));
1809         __f_ = _VSTD::addressof(*__hold.release());
1810     }
1811 }
1812
1813 template<class _Rp, class ..._ArgTypes>
1814 __packaged_task_function<_Rp(_ArgTypes...)>&
1815 __packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT
1816 {
1817     if (__f_ == __get_buf())
1818         __f_->destroy();
1819     else if (__f_)
1820         __f_->destroy_deallocate();
1821     __f_ = nullptr;
1822     if (__f.__f_ == nullptr)
1823         __f_ = nullptr;
1824     else if (__f.__f_ == __f.__get_buf())
1825     {
1826         __f.__f_->__move_to(__get_buf());
1827         __f_ = __get_buf();
1828     }
1829     else
1830     {
1831         __f_ = __f.__f_;
1832         __f.__f_ = nullptr;
1833     }
1834     return *this;
1835 }
1836
1837 template<class _Rp, class ..._ArgTypes>
1838 __packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function()
1839 {
1840     if (__f_ == __get_buf())
1841         __f_->destroy();
1842     else if (__f_)
1843         __f_->destroy_deallocate();
1844 }
1845
1846 template<class _Rp, class ..._ArgTypes>
1847 _LIBCPP_NO_CFI
1848 void
1849 __packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT
1850 {
1851     if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
1852     {
1853         _LIBCPP_SUPPRESS_DEPRECATED_PUSH
1854         typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
1855         _LIBCPP_SUPPRESS_DEPRECATED_POP
1856         __base* __t = (__base*)&__tempbuf;
1857         __f_->__move_to(__t);
1858         __f_->destroy();
1859         __f_ = nullptr;
1860         __f.__f_->__move_to((__base*)&__buf_);
1861         __f.__f_->destroy();
1862         __f.__f_ = nullptr;
1863         __f_ = (__base*)&__buf_;
1864         __t->__move_to((__base*)&__f.__buf_);
1865         __t->destroy();
1866         __f.__f_ = (__base*)&__f.__buf_;
1867     }
1868     else if (__f_ == (__base*)&__buf_)
1869     {
1870         __f_->__move_to((__base*)&__f.__buf_);
1871         __f_->destroy();
1872         __f_ = __f.__f_;
1873         __f.__f_ = (__base*)&__f.__buf_;
1874     }
1875     else if (__f.__f_ == (__base*)&__f.__buf_)
1876     {
1877         __f.__f_->__move_to((__base*)&__buf_);
1878         __f.__f_->destroy();
1879         __f.__f_ = __f_;
1880         __f_ = (__base*)&__buf_;
1881     }
1882     else
1883         _VSTD::swap(__f_, __f.__f_);
1884 }
1885
1886 template<class _Rp, class ..._ArgTypes>
1887 inline
1888 _Rp
1889 __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
1890 {
1891     return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
1892 }
1893
1894 template<class _Rp, class ..._ArgTypes>
1895 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<_Rp(_ArgTypes...)>
1896 {
1897 public:
1898     typedef _Rp result_type; // extension
1899
1900 private:
1901     __packaged_task_function<result_type(_ArgTypes...)> __f_;
1902     promise<result_type>                                __p_;
1903
1904 public:
1905     // construction and destruction
1906     _LIBCPP_INLINE_VISIBILITY
1907     packaged_task() _NOEXCEPT : __p_(nullptr) {}
1908     template <class _Fp,
1909               class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
1910         _LIBCPP_INLINE_VISIBILITY
1911         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
1912     template <class _Fp, class _Allocator,
1913               class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
1914         _LIBCPP_INLINE_VISIBILITY
1915         packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
1916              : __f_(allocator_arg_t(), __a, _VSTD::forward<_Fp>(__f)),
1917                __p_(allocator_arg_t(), __a) {}
1918     // ~packaged_task() = default;
1919
1920     // no copy
1921     packaged_task(const packaged_task&) = delete;
1922     packaged_task& operator=(const packaged_task&) = delete;
1923
1924     // move support
1925     _LIBCPP_INLINE_VISIBILITY
1926     packaged_task(packaged_task&& __other) _NOEXCEPT
1927         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
1928     _LIBCPP_INLINE_VISIBILITY
1929     packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
1930     {
1931         __f_ = _VSTD::move(__other.__f_);
1932         __p_ = _VSTD::move(__other.__p_);
1933         return *this;
1934     }
1935     _LIBCPP_INLINE_VISIBILITY
1936     void swap(packaged_task& __other) _NOEXCEPT
1937     {
1938         __f_.swap(__other.__f_);
1939         __p_.swap(__other.__p_);
1940     }
1941
1942     _LIBCPP_INLINE_VISIBILITY
1943     bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
1944
1945     // result retrieval
1946     _LIBCPP_INLINE_VISIBILITY
1947     future<result_type> get_future() {return __p_.get_future();}
1948
1949     // execution
1950     _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);
1951     _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args);
1952
1953     _LIBCPP_HIDE_FROM_ABI void reset();
1954 };
1955
1956 template<class _Rp, class ..._ArgTypes>
1957 void
1958 packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args)
1959 {
1960     if (__p_.__state_ == nullptr)
1961         __throw_future_error(future_errc::no_state);
1962     if (__p_.__state_->__has_value())
1963         __throw_future_error(future_errc::promise_already_satisfied);
1964 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
1965     try
1966     {
1967 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
1968         __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
1969 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
1970     }
1971     catch (...)
1972     {
1973         __p_.set_exception(current_exception());
1974     }
1975 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
1976 }
1977
1978 template<class _Rp, class ..._ArgTypes>
1979 void
1980 packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
1981 {
1982     if (__p_.__state_ == nullptr)
1983         __throw_future_error(future_errc::no_state);
1984     if (__p_.__state_->__has_value())
1985         __throw_future_error(future_errc::promise_already_satisfied);
1986 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
1987     try
1988     {
1989 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
1990         __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
1991 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
1992     }
1993     catch (...)
1994     {
1995         __p_.set_exception_at_thread_exit(current_exception());
1996     }
1997 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
1998 }
1999
2000 template<class _Rp, class ..._ArgTypes>
2001 void
2002 packaged_task<_Rp(_ArgTypes...)>::reset()
2003 {
2004     if (!valid())
2005         __throw_future_error(future_errc::no_state);
2006     __p_ = promise<result_type>();
2007 }
2008
2009 template<class ..._ArgTypes>
2010 class _LIBCPP_TEMPLATE_VIS _LIBCPP_AVAILABILITY_FUTURE packaged_task<void(_ArgTypes...)>
2011 {
2012 public:
2013     typedef void result_type; // extension
2014
2015 private:
2016     __packaged_task_function<result_type(_ArgTypes...)> __f_;
2017     promise<result_type>                                __p_;
2018
2019 public:
2020     // construction and destruction
2021     _LIBCPP_INLINE_VISIBILITY
2022     packaged_task() _NOEXCEPT : __p_(nullptr) {}
2023     template <class _Fp,
2024               class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
2025         _LIBCPP_INLINE_VISIBILITY
2026         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
2027     template <class _Fp, class _Allocator,
2028               class = __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value> >
2029         _LIBCPP_INLINE_VISIBILITY
2030         packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
2031              : __f_(allocator_arg_t(), __a, _VSTD::forward<_Fp>(__f)),
2032                __p_(allocator_arg_t(), __a) {}
2033     // ~packaged_task() = default;
2034
2035     // no copy
2036     packaged_task(const packaged_task&) = delete;
2037     packaged_task& operator=(const packaged_task&) = delete;
2038
2039     // move support
2040     _LIBCPP_INLINE_VISIBILITY
2041     packaged_task(packaged_task&& __other) _NOEXCEPT
2042         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
2043     _LIBCPP_INLINE_VISIBILITY
2044     packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
2045     {
2046         __f_ = _VSTD::move(__other.__f_);
2047         __p_ = _VSTD::move(__other.__p_);
2048         return *this;
2049     }
2050     _LIBCPP_INLINE_VISIBILITY
2051     void swap(packaged_task& __other) _NOEXCEPT
2052     {
2053         __f_.swap(__other.__f_);
2054         __p_.swap(__other.__p_);
2055     }
2056
2057     _LIBCPP_INLINE_VISIBILITY
2058     bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
2059
2060     // result retrieval
2061     _LIBCPP_INLINE_VISIBILITY
2062     future<result_type> get_future() {return __p_.get_future();}
2063
2064     // execution
2065     _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);
2066     _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args);
2067
2068     _LIBCPP_HIDE_FROM_ABI void reset();
2069 };
2070
2071 #if _LIBCPP_STD_VER >= 17
2072
2073 template <class _Rp, class... _Args>
2074 packaged_task(_Rp(*)(_Args...)) -> packaged_task<_Rp(_Args...)>;
2075
2076 template <class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type>
2077 packaged_task(_Fp) -> packaged_task<_Stripped>;
2078
2079 #endif
2080
2081 template<class ..._ArgTypes>
2082 void
2083 packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
2084 {
2085     if (__p_.__state_ == nullptr)
2086         __throw_future_error(future_errc::no_state);
2087     if (__p_.__state_->__has_value())
2088         __throw_future_error(future_errc::promise_already_satisfied);
2089 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
2090     try
2091     {
2092 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
2093         __f_(_VSTD::forward<_ArgTypes>(__args)...);
2094         __p_.set_value();
2095 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
2096     }
2097     catch (...)
2098     {
2099         __p_.set_exception(current_exception());
2100     }
2101 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
2102 }
2103
2104 template<class ..._ArgTypes>
2105 void
2106 packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
2107 {
2108     if (__p_.__state_ == nullptr)
2109         __throw_future_error(future_errc::no_state);
2110     if (__p_.__state_->__has_value())
2111         __throw_future_error(future_errc::promise_already_satisfied);
2112 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
2113     try
2114     {
2115 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
2116         __f_(_VSTD::forward<_ArgTypes>(__args)...);
2117         __p_.set_value_at_thread_exit();
2118 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
2119     }
2120     catch (...)
2121     {
2122         __p_.set_exception_at_thread_exit(current_exception());
2123     }
2124 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
2125 }
2126
2127 template<class ..._ArgTypes>
2128 void
2129 packaged_task<void(_ArgTypes...)>::reset()
2130 {
2131     if (!valid())
2132         __throw_future_error(future_errc::no_state);
2133     __p_ = promise<result_type>();
2134 }
2135
2136 template <class _Rp, class... _ArgTypes>
2137 inline _LIBCPP_INLINE_VISIBILITY
2138 void
2139 swap(packaged_task<_Rp(_ArgTypes...)>& __x, packaged_task<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
2140 {
2141     __x.swap(__y);
2142 }
2143
2144 template <class _Callable, class _Alloc>
2145 struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>
2146     : public true_type {};
2147
2148 template <class _Rp, class _Fp>
2149 _LIBCPP_INLINE_VISIBILITY future<_Rp>
2150 __make_deferred_assoc_state(_Fp&& __f)
2151 {
2152     unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count>
2153         __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
2154     return future<_Rp>(__h.get());
2155 }
2156
2157 template <class _Rp, class _Fp>
2158 _LIBCPP_INLINE_VISIBILITY future<_Rp>
2159 __make_async_assoc_state(_Fp&& __f)
2160 {
2161     unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count>
2162         __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
2163     _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
2164     return future<_Rp>(__h.get());
2165 }
2166
2167 #ifndef _LIBCPP_CXX03_LANG
2168
2169 template <class _Fp, class... _Args>
2170 class _LIBCPP_HIDDEN __async_func
2171 {
2172     tuple<_Fp, _Args...> __f_;
2173
2174 public:
2175     typedef typename __invoke_of<_Fp, _Args...>::type _Rp;
2176
2177     _LIBCPP_INLINE_VISIBILITY
2178     explicit __async_func(_Fp&& __f, _Args&&... __args)
2179         : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}
2180
2181     _LIBCPP_INLINE_VISIBILITY
2182     __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {}
2183
2184     _LIBCPP_HIDE_FROM_ABI _Rp operator()()
2185     {
2186         typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index;
2187         return __execute(_Index());
2188     }
2189 private:
2190     template <size_t ..._Indices>
2191     _LIBCPP_HIDE_FROM_ABI _Rp
2192     __execute(__tuple_indices<_Indices...>)
2193     {
2194         return _VSTD::__invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
2195     }
2196 };
2197
2198 inline _LIBCPP_INLINE_VISIBILITY bool __does_policy_contain(launch __policy, launch __value )
2199 { return (int(__policy) & int(__value)) != 0; }
2200
2201 template <class _Fp, class... _Args>
2202 _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI
2203 future<typename __invoke_of<__decay_t<_Fp>, __decay_t<_Args>...>::type>
2204 async(launch __policy, _Fp&& __f, _Args&&... __args)
2205 {
2206     typedef __async_func<__decay_t<_Fp>, __decay_t<_Args>...> _BF;
2207     typedef typename _BF::_Rp _Rp;
2208
2209 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
2210     try
2211     {
2212 #endif
2213         if (__does_policy_contain(__policy, launch::async))
2214         return _VSTD::__make_async_assoc_state<_Rp>(_BF(_LIBCPP_AUTO_CAST(_VSTD::forward<_Fp>(__f)),
2215                                                         _LIBCPP_AUTO_CAST(_VSTD::forward<_Args>(__args))...));
2216 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
2217     }
2218     catch ( ... ) { if (__policy == launch::async) throw ; }
2219 #endif
2220
2221     if (__does_policy_contain(__policy, launch::deferred))
2222         return _VSTD::__make_deferred_assoc_state<_Rp>(_BF(_LIBCPP_AUTO_CAST(_VSTD::forward<_Fp>(__f)),
2223                                                            _LIBCPP_AUTO_CAST(_VSTD::forward<_Args>(__args))...));
2224     return future<_Rp>{};
2225 }
2226
2227 template <class _Fp, class... _Args>
2228 _LIBCPP_NODISCARD_AFTER_CXX17 inline _LIBCPP_INLINE_VISIBILITY
2229 future<typename __invoke_of<__decay_t<_Fp>, __decay_t<_Args>...>::type>
2230 async(_Fp&& __f, _Args&&... __args)
2231 {
2232     return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f),
2233                                     _VSTD::forward<_Args>(__args)...);
2234 }
2235
2236 #endif // C++03
2237
2238 // shared_future
2239
2240 template <class _Rp>
2241 class _LIBCPP_TEMPLATE_VIS shared_future
2242 {
2243     __assoc_state<_Rp>* __state_;
2244
2245 public:
2246     _LIBCPP_INLINE_VISIBILITY
2247     shared_future() _NOEXCEPT : __state_(nullptr) {}
2248     _LIBCPP_INLINE_VISIBILITY
2249     shared_future(const shared_future& __rhs)  _NOEXCEPT : __state_(__rhs.__state_)
2250         {if (__state_) __state_->__add_shared();}
2251     _LIBCPP_INLINE_VISIBILITY
2252     shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_)
2253         {__f.__state_ = nullptr;}
2254     _LIBCPP_INLINE_VISIBILITY
2255     shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
2256         {__rhs.__state_ = nullptr;}
2257     _LIBCPP_HIDE_FROM_ABI ~shared_future();
2258     _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs) _NOEXCEPT;
2259     _LIBCPP_INLINE_VISIBILITY
2260     shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
2261         {
2262             shared_future(_VSTD::move(__rhs)).swap(*this);
2263             return *this;
2264         }
2265
2266     // retrieving the value
2267     _LIBCPP_INLINE_VISIBILITY
2268     const _Rp& get() const {return __state_->copy();}
2269
2270     _LIBCPP_INLINE_VISIBILITY
2271     void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
2272
2273     // functions to check state
2274     _LIBCPP_INLINE_VISIBILITY
2275     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
2276
2277     _LIBCPP_INLINE_VISIBILITY
2278     void wait() const {__state_->wait();}
2279     template <class _Rep, class _Period>
2280         _LIBCPP_INLINE_VISIBILITY
2281         future_status
2282         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
2283             {return __state_->wait_for(__rel_time);}
2284     template <class _Clock, class _Duration>
2285         _LIBCPP_INLINE_VISIBILITY
2286         future_status
2287         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
2288             {return __state_->wait_until(__abs_time);}
2289 };
2290
2291 template <class _Rp>
2292 shared_future<_Rp>::~shared_future()
2293 {
2294     if (__state_)
2295         __state_->__release_shared();
2296 }
2297
2298 template <class _Rp>
2299 shared_future<_Rp>&
2300 shared_future<_Rp>::operator=(const shared_future& __rhs) _NOEXCEPT
2301 {
2302     if (__rhs.__state_)
2303         __rhs.__state_->__add_shared();
2304     if (__state_)
2305         __state_->__release_shared();
2306     __state_ = __rhs.__state_;
2307     return *this;
2308 }
2309
2310 template <class _Rp>
2311 class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&>
2312 {
2313     __assoc_state<_Rp&>* __state_;
2314
2315 public:
2316     _LIBCPP_INLINE_VISIBILITY
2317     shared_future() _NOEXCEPT : __state_(nullptr) {}
2318     _LIBCPP_INLINE_VISIBILITY
2319     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
2320         {if (__state_) __state_->__add_shared();}
2321     _LIBCPP_INLINE_VISIBILITY
2322     shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_)
2323         {__f.__state_ = nullptr;}
2324     _LIBCPP_INLINE_VISIBILITY
2325     shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
2326         {__rhs.__state_ = nullptr;}
2327     _LIBCPP_HIDE_FROM_ABI ~shared_future();
2328     _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs);
2329     _LIBCPP_INLINE_VISIBILITY
2330     shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
2331         {
2332             shared_future(_VSTD::move(__rhs)).swap(*this);
2333             return *this;
2334         }
2335
2336     // retrieving the value
2337     _LIBCPP_INLINE_VISIBILITY
2338     _Rp& get() const {return __state_->copy();}
2339
2340     _LIBCPP_INLINE_VISIBILITY
2341     void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
2342
2343     // functions to check state
2344     _LIBCPP_INLINE_VISIBILITY
2345     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
2346
2347     _LIBCPP_INLINE_VISIBILITY
2348     void wait() const {__state_->wait();}
2349     template <class _Rep, class _Period>
2350         _LIBCPP_INLINE_VISIBILITY
2351         future_status
2352         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
2353             {return __state_->wait_for(__rel_time);}
2354     template <class _Clock, class _Duration>
2355         _LIBCPP_INLINE_VISIBILITY
2356         future_status
2357         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
2358             {return __state_->wait_until(__abs_time);}
2359 };
2360
2361 template <class _Rp>
2362 shared_future<_Rp&>::~shared_future()
2363 {
2364     if (__state_)
2365         __state_->__release_shared();
2366 }
2367
2368 template <class _Rp>
2369 shared_future<_Rp&>&
2370 shared_future<_Rp&>::operator=(const shared_future& __rhs)
2371 {
2372     if (__rhs.__state_)
2373         __rhs.__state_->__add_shared();
2374     if (__state_)
2375         __state_->__release_shared();
2376     __state_ = __rhs.__state_;
2377     return *this;
2378 }
2379
2380 template <>
2381 class _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_AVAILABILITY_FUTURE shared_future<void>
2382 {
2383     __assoc_sub_state* __state_;
2384
2385 public:
2386     _LIBCPP_INLINE_VISIBILITY
2387     shared_future() _NOEXCEPT : __state_(nullptr) {}
2388     _LIBCPP_INLINE_VISIBILITY
2389     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
2390         {if (__state_) __state_->__add_shared();}
2391     _LIBCPP_INLINE_VISIBILITY
2392     shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_)
2393         {__f.__state_ = nullptr;}
2394     _LIBCPP_INLINE_VISIBILITY
2395     shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
2396         {__rhs.__state_ = nullptr;}
2397     ~shared_future();
2398     shared_future& operator=(const shared_future& __rhs);
2399     _LIBCPP_INLINE_VISIBILITY
2400     shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
2401         {
2402             shared_future(_VSTD::move(__rhs)).swap(*this);
2403             return *this;
2404         }
2405
2406     // retrieving the value
2407     _LIBCPP_INLINE_VISIBILITY
2408     void get() const {__state_->copy();}
2409
2410     _LIBCPP_INLINE_VISIBILITY
2411     void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
2412
2413     // functions to check state
2414     _LIBCPP_INLINE_VISIBILITY
2415     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
2416
2417     _LIBCPP_INLINE_VISIBILITY
2418     void wait() const {__state_->wait();}
2419     template <class _Rep, class _Period>
2420         _LIBCPP_INLINE_VISIBILITY
2421         future_status
2422         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
2423             {return __state_->wait_for(__rel_time);}
2424     template <class _Clock, class _Duration>
2425         _LIBCPP_INLINE_VISIBILITY
2426         future_status
2427         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
2428             {return __state_->wait_until(__abs_time);}
2429 };
2430
2431 template <class _Rp>
2432 inline _LIBCPP_INLINE_VISIBILITY
2433 void
2434 swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT
2435 {
2436     __x.swap(__y);
2437 }
2438
2439 template <class _Rp>
2440 inline
2441 shared_future<_Rp>
2442 future<_Rp>::share() _NOEXCEPT
2443 {
2444     return shared_future<_Rp>(_VSTD::move(*this));
2445 }
2446
2447 template <class _Rp>
2448 inline
2449 shared_future<_Rp&>
2450 future<_Rp&>::share() _NOEXCEPT
2451 {
2452     return shared_future<_Rp&>(_VSTD::move(*this));
2453 }
2454
2455 inline
2456 shared_future<void>
2457 future<void>::share() _NOEXCEPT
2458 {
2459     return shared_future<void>(_VSTD::move(*this));
2460 }
2461
2462 _LIBCPP_END_NAMESPACE_STD
2463
2464 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17
2465 #  include <chrono>
2466 #endif
2467
2468 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
2469 #  include <atomic>
2470 #  include <cstdlib>
2471 #  include <exception>
2472 #  include <system_error>
2473 #endif
2474
2475 #endif // _LIBCPP_FUTURE