contrib/libc++/include/future

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