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 _LIBCXX_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 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_ALWAYS_INLINE
 518 void __throw_future_error(future_errc _Ev)
 519 {
 520 #ifndef _LIBCPP_NO_EXCEPTIONS
 521     throw future_error(make_error_code(_Ev));
 522 #else
 523     ((void)_Ev);
 524     _VSTD::abort();
 525 #endif
 526 }
 527
 528 class _LIBCPP_TYPE_VIS __assoc_sub_state
 529     : public __shared_count
 530 {
 531 protected:
 532     exception_ptr __exception_;
 533     mutable mutex __mut_;
 534     mutable condition_variable __cv_;
 535     unsigned __state_;
 536
 537     virtual void __on_zero_shared() _NOEXCEPT;
 538     void __sub_wait(unique_lock<mutex>& __lk);
 539 public:
 540     enum
 541     {
 542         __constructed = 1,
 543         __future_attached = 2,
 544         ready = 4,
 545         deferred = 8
 546     };
 547
 548     _LIBCPP_INLINE_VISIBILITY
 549     __assoc_sub_state() : __state_(0) {}
 550
 551     _LIBCPP_INLINE_VISIBILITY
 552     bool __has_value() const
 553         {return (__state_ & __constructed) || (__exception_ != nullptr);}
 554
 555     _LIBCPP_INLINE_VISIBILITY
 556     void __set_future_attached()
 557     {
 558         lock_guard<mutex> __lk(__mut_);
 559         __state_ |= __future_attached;
 560     }
 561     _LIBCPP_INLINE_VISIBILITY
 562     bool __has_future_attached() const {return (__state_ & __future_attached) != 0;}
 563
 564     _LIBCPP_INLINE_VISIBILITY
 565     void __set_deferred() {__state_ |= deferred;}
 566
 567     void __make_ready();
 568     _LIBCPP_INLINE_VISIBILITY
 569     bool __is_ready() const {return (__state_ & ready) != 0;}
 570
 571     void set_value();
 572     void set_value_at_thread_exit();
 573
 574     void set_exception(exception_ptr __p);
 575     void set_exception_at_thread_exit(exception_ptr __p);
 576
 577     void copy();
 578
 579     void wait();
 580     template <class _Rep, class _Period>
 581         future_status
 582         _LIBCPP_INLINE_VISIBILITY
 583         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;
 584     template <class _Clock, class _Duration>
 585         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
 586         future_status
 587         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;
 588
 589     virtual void __execute();
 590 };
 591
 592 template <class _Clock, class _Duration>
 593 future_status
 594 __assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 595 {
 596     unique_lock<mutex> __lk(__mut_);
 597     if (__state_ & deferred)
 598         return future_status::deferred;
 599     while (!(__state_ & ready) && _Clock::now() < __abs_time)
 600         __cv_.wait_until(__lk, __abs_time);
 601     if (__state_ & ready)
 602         return future_status::ready;
 603     return future_status::timeout;
 604 }
 605
 606 template <class _Rep, class _Period>
 607 inline
 608 future_status
 609 __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 610 {
 611     return wait_until(chrono::steady_clock::now() + __rel_time);
 612 }
 613
 614 template <class _Rp>
 615 class __assoc_state
 616     : public __assoc_sub_state
 617 {
 618     typedef __assoc_sub_state base;
 619     typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;
 620 protected:
 621     _Up __value_;
 622
 623     virtual void __on_zero_shared() _NOEXCEPT;
 624 public:
 625
 626     template <class _Arg>
 627 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 628         void set_value(_Arg&& __arg);
 629 #else
 630         void set_value(_Arg& __arg);
 631 #endif
 632
 633     template <class _Arg>
 634 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 635         void set_value_at_thread_exit(_Arg&& __arg);
 636 #else
 637         void set_value_at_thread_exit(_Arg& __arg);
 638 #endif
 639
 640     _Rp move();
 641     typename add_lvalue_reference<_Rp>::type copy();
 642 };
 643
 644 template <class _Rp>
 645 void
 646 __assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT
 647 {
 648     if (this->__state_ & base::__constructed)
 649         reinterpret_cast<_Rp*>(&__value_)->~_Rp();
 650     delete this;
 651 }
 652
 653 template <class _Rp>
 654 template <class _Arg>
 655 void
 656 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 657 __assoc_state<_Rp>::set_value(_Arg&& __arg)
 658 #else
 659 __assoc_state<_Rp>::set_value(_Arg& __arg)
 660 #endif
 661 {
 662     unique_lock<mutex> __lk(this->__mut_);
 663     if (this->__has_value())
 664         __throw_future_error(future_errc::promise_already_satisfied);
 665     ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
 666     this->__state_ |= base::__constructed | base::ready;
 667     __cv_.notify_all();
 668 }
 669
 670 template <class _Rp>
 671 template <class _Arg>
 672 void
 673 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 674 __assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg)
 675 #else
 676 __assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg)
 677 #endif
 678 {
 679     unique_lock<mutex> __lk(this->__mut_);
 680     if (this->__has_value())
 681         __throw_future_error(future_errc::promise_already_satisfied);
 682     ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
 683     this->__state_ |= base::__constructed;
 684     __thread_local_data()->__make_ready_at_thread_exit(this);
 685 }
 686
 687 template <class _Rp>
 688 _Rp
 689 __assoc_state<_Rp>::move()
 690 {
 691     unique_lock<mutex> __lk(this->__mut_);
 692     this->__sub_wait(__lk);
 693     if (this->__exception_ != nullptr)
 694         rethrow_exception(this->__exception_);
 695     return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));
 696 }
 697
 698 template <class _Rp>
 699 typename add_lvalue_reference<_Rp>::type
 700 __assoc_state<_Rp>::copy()
 701 {
 702     unique_lock<mutex> __lk(this->__mut_);
 703     this->__sub_wait(__lk);
 704     if (this->__exception_ != nullptr)
 705         rethrow_exception(this->__exception_);
 706     return *reinterpret_cast<_Rp*>(&__value_);
 707 }
 708
 709 template <class _Rp>
 710 class __assoc_state<_Rp&>
 711     : public __assoc_sub_state
 712 {
 713     typedef __assoc_sub_state base;
 714     typedef _Rp* _Up;
 715 protected:
 716     _Up __value_;
 717
 718     virtual void __on_zero_shared() _NOEXCEPT;
 719 public:
 720
 721     void set_value(_Rp& __arg);
 722     void set_value_at_thread_exit(_Rp& __arg);
 723
 724     _Rp& copy();
 725 };
 726
 727 template <class _Rp>
 728 void
 729 __assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT
 730 {
 731     delete this;
 732 }
 733
 734 template <class _Rp>
 735 void
 736 __assoc_state<_Rp&>::set_value(_Rp& __arg)
 737 {
 738     unique_lock<mutex> __lk(this->__mut_);
 739     if (this->__has_value())
 740         __throw_future_error(future_errc::promise_already_satisfied);
 741     __value_ = _VSTD::addressof(__arg);
 742     this->__state_ |= base::__constructed | base::ready;
 743     __cv_.notify_all();
 744 }
 745
 746 template <class _Rp>
 747 void
 748 __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg)
 749 {
 750     unique_lock<mutex> __lk(this->__mut_);
 751     if (this->__has_value())
 752         __throw_future_error(future_errc::promise_already_satisfied);
 753     __value_ = _VSTD::addressof(__arg);
 754     this->__state_ |= base::__constructed;
 755     __thread_local_data()->__make_ready_at_thread_exit(this);
 756 }
 757
 758 template <class _Rp>
 759 _Rp&
 760 __assoc_state<_Rp&>::copy()
 761 {
 762     unique_lock<mutex> __lk(this->__mut_);
 763     this->__sub_wait(__lk);
 764     if (this->__exception_ != nullptr)
 765         rethrow_exception(this->__exception_);
 766     return *__value_;
 767 }
 768
 769 template <class _Rp, class _Alloc>
 770 class __assoc_state_alloc
 771     : public __assoc_state<_Rp>
 772 {
 773     typedef __assoc_state<_Rp> base;
 774     _Alloc __alloc_;
 775
 776     virtual void __on_zero_shared() _NOEXCEPT;
 777 public:
 778     _LIBCPP_INLINE_VISIBILITY
 779     explicit __assoc_state_alloc(const _Alloc& __a)
 780         : __alloc_(__a) {}
 781 };
 782
 783 template <class _Rp, class _Alloc>
 784 void
 785 __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT
 786 {
 787     if (this->__state_ & base::__constructed)
 788         reinterpret_cast<_Rp*>(_VSTD::addressof(this->__value_))->~_Rp();
 789     typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
 790     typedef allocator_traits<_Al> _ATraits;
 791     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
 792     _Al __a(__alloc_);
 793     this->~__assoc_state_alloc();
 794     __a.deallocate(_PTraits::pointer_to(*this), 1);
 795 }
 796
 797 template <class _Rp, class _Alloc>
 798 class __assoc_state_alloc<_Rp&, _Alloc>
 799     : public __assoc_state<_Rp&>
 800 {
 801     typedef __assoc_state<_Rp&> base;
 802     _Alloc __alloc_;
 803
 804     virtual void __on_zero_shared() _NOEXCEPT;
 805 public:
 806     _LIBCPP_INLINE_VISIBILITY
 807     explicit __assoc_state_alloc(const _Alloc& __a)
 808         : __alloc_(__a) {}
 809 };
 810
 811 template <class _Rp, class _Alloc>
 812 void
 813 __assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT
 814 {
 815     typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;
 816     typedef allocator_traits<_Al> _ATraits;
 817     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
 818     _Al __a(__alloc_);
 819     this->~__assoc_state_alloc();
 820     __a.deallocate(_PTraits::pointer_to(*this), 1);
 821 }
 822
 823 template <class _Alloc>
 824 class __assoc_sub_state_alloc
 825     : public __assoc_sub_state
 826 {
 827     typedef __assoc_sub_state base;
 828     _Alloc __alloc_;
 829
 830     virtual void __on_zero_shared() _NOEXCEPT;
 831 public:
 832     _LIBCPP_INLINE_VISIBILITY
 833     explicit __assoc_sub_state_alloc(const _Alloc& __a)
 834         : __alloc_(__a) {}
 835 };
 836
 837 template <class _Alloc>
 838 void
 839 __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT
 840 {
 841     typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al;
 842     typedef allocator_traits<_Al> _ATraits;
 843     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
 844     _Al __a(__alloc_);
 845     this->~__assoc_sub_state_alloc();
 846     __a.deallocate(_PTraits::pointer_to(*this), 1);
 847 }
 848
 849 template <class _Rp, class _Fp>
 850 class __deferred_assoc_state
 851     : public __assoc_state<_Rp>
 852 {
 853     typedef __assoc_state<_Rp> base;
 854
 855     _Fp __func_;
 856
 857 public:
 858 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 859     _LIBCPP_INLINE_VISIBILITY
 860     explicit __deferred_assoc_state(_Fp&& __f);
 861 #endif
 862
 863     virtual void __execute();
 864 };
 865
 866 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 867
 868 template <class _Rp, class _Fp>
 869 inline
 870 __deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f)
 871     : __func_(_VSTD::forward<_Fp>(__f))
 872 {
 873     this->__set_deferred();
 874 }
 875
 876 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 877
 878 template <class _Rp, class _Fp>
 879 void
 880 __deferred_assoc_state<_Rp, _Fp>::__execute()
 881 {
 882 #ifndef _LIBCPP_NO_EXCEPTIONS
 883     try
 884     {
 885 #endif  // _LIBCPP_NO_EXCEPTIONS
 886         this->set_value(__func_());
 887 #ifndef _LIBCPP_NO_EXCEPTIONS
 888     }
 889     catch (...)
 890     {
 891         this->set_exception(current_exception());
 892     }
 893 #endif  // _LIBCPP_NO_EXCEPTIONS
 894 }
 895
 896 template <class _Fp>
 897 class __deferred_assoc_state<void, _Fp>
 898     : public __assoc_sub_state
 899 {
 900     typedef __assoc_sub_state base;
 901
 902     _Fp __func_;
 903
 904 public:
 905 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 906     _LIBCPP_INLINE_VISIBILITY
 907     explicit __deferred_assoc_state(_Fp&& __f);
 908 #endif
 909
 910     virtual void __execute();
 911 };
 912
 913 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 914
 915 template <class _Fp>
 916 inline
 917 __deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)
 918     : __func_(_VSTD::forward<_Fp>(__f))
 919 {
 920     this->__set_deferred();
 921 }
 922
 923 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 924
 925 template <class _Fp>
 926 void
 927 __deferred_assoc_state<void, _Fp>::__execute()
 928 {
 929 #ifndef _LIBCPP_NO_EXCEPTIONS
 930     try
 931     {
 932 #endif  // _LIBCPP_NO_EXCEPTIONS
 933         __func_();
 934         this->set_value();
 935 #ifndef _LIBCPP_NO_EXCEPTIONS
 936     }
 937     catch (...)
 938     {
 939         this->set_exception(current_exception());
 940     }
 941 #endif  // _LIBCPP_NO_EXCEPTIONS
 942 }
 943
 944 template <class _Rp, class _Fp>
 945 class __async_assoc_state
 946     : public __assoc_state<_Rp>
 947 {
 948     typedef __assoc_state<_Rp> base;
 949
 950     _Fp __func_;
 951
 952     virtual void __on_zero_shared() _NOEXCEPT;
 953 public:
 954 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 955     _LIBCPP_INLINE_VISIBILITY
 956     explicit __async_assoc_state(_Fp&& __f);
 957 #endif
 958
 959     virtual void __execute();
 960 };
 961
 962 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 963
 964 template <class _Rp, class _Fp>
 965 inline
 966 __async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)
 967     : __func_(_VSTD::forward<_Fp>(__f))
 968 {
 969 }
 970
 971 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 972
 973 template <class _Rp, class _Fp>
 974 void
 975 __async_assoc_state<_Rp, _Fp>::__execute()
 976 {
 977 #ifndef _LIBCPP_NO_EXCEPTIONS
 978     try
 979     {
 980 #endif  // _LIBCPP_NO_EXCEPTIONS
 981         this->set_value(__func_());
 982 #ifndef _LIBCPP_NO_EXCEPTIONS
 983     }
 984     catch (...)
 985     {
 986         this->set_exception(current_exception());
 987     }
 988 #endif  // _LIBCPP_NO_EXCEPTIONS
 989 }
 990
 991 template <class _Rp, class _Fp>
 992 void
 993 __async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT
 994 {
 995     this->wait();
 996     base::__on_zero_shared();
 997 }
 998
 999 template <class _Fp>
1000 class __async_assoc_state<void, _Fp>
1001     : public __assoc_sub_state
1002 {
1003     typedef __assoc_sub_state base;
1004
1005     _Fp __func_;
1006
1007     virtual void __on_zero_shared() _NOEXCEPT;
1008 public:
1009 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1010     _LIBCPP_INLINE_VISIBILITY
1011     explicit __async_assoc_state(_Fp&& __f);
1012 #endif
1013
1014     virtual void __execute();
1015 };
1016
1017 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1018
1019 template <class _Fp>
1020 inline
1021 __async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
1022     : __func_(_VSTD::forward<_Fp>(__f))
1023 {
1024 }
1025
1026 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1027
1028 template <class _Fp>
1029 void
1030 __async_assoc_state<void, _Fp>::__execute()
1031 {
1032 #ifndef _LIBCPP_NO_EXCEPTIONS
1033     try
1034     {
1035 #endif  // _LIBCPP_NO_EXCEPTIONS
1036         __func_();
1037         this->set_value();
1038 #ifndef _LIBCPP_NO_EXCEPTIONS
1039     }
1040     catch (...)
1041     {
1042         this->set_exception(current_exception());
1043     }
1044 #endif  // _LIBCPP_NO_EXCEPTIONS
1045 }
1046
1047 template <class _Fp>
1048 void
1049 __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT
1050 {
1051     this->wait();
1052     base::__on_zero_shared();
1053 }
1054
1055 template <class _Rp> class _LIBCPP_TEMPLATE_VIS promise;
1056 template <class _Rp> class _LIBCPP_TEMPLATE_VIS shared_future;
1057
1058 // future
1059
1060 template <class _Rp> class _LIBCPP_TEMPLATE_VIS future;
1061
1062 template <class _Rp, class _Fp>
1063 future<_Rp>
1064 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1065 __make_deferred_assoc_state(_Fp&& __f);
1066 #else
1067 __make_deferred_assoc_state(_Fp __f);
1068 #endif
1069
1070 template <class _Rp, class _Fp>
1071 future<_Rp>
1072 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1073 __make_async_assoc_state(_Fp&& __f);
1074 #else
1075 __make_async_assoc_state(_Fp __f);
1076 #endif
1077
1078 template <class _Rp>
1079 class _LIBCPP_TEMPLATE_VIS future
1080 {
1081     __assoc_state<_Rp>* __state_;
1082
1083     explicit future(__assoc_state<_Rp>* __state);
1084
1085     template <class> friend class promise;
1086     template <class> friend class shared_future;
1087
1088 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1089     template <class _R1, class _Fp>
1090         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
1091     template <class _R1, class _Fp>
1092         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
1093 #else
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 #endif
1099
1100 public:
1101     _LIBCPP_INLINE_VISIBILITY
1102     future() _NOEXCEPT : __state_(nullptr) {}
1103 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1104     _LIBCPP_INLINE_VISIBILITY
1105     future(future&& __rhs) _NOEXCEPT
1106         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1107     future(const future&) = delete;
1108     future& operator=(const future&) = delete;
1109     _LIBCPP_INLINE_VISIBILITY
1110     future& operator=(future&& __rhs) _NOEXCEPT
1111         {
1112             future(std::move(__rhs)).swap(*this);
1113             return *this;
1114         }
1115 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1116 private:
1117     future(const future&);
1118     future& operator=(const future&);
1119 public:
1120 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1121     ~future();
1122     _LIBCPP_INLINE_VISIBILITY
1123     shared_future<_Rp> share() _NOEXCEPT;
1124
1125     // retrieving the value
1126     _Rp get();
1127
1128     _LIBCPP_INLINE_VISIBILITY
1129     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1130
1131     // functions to check state
1132     _LIBCPP_INLINE_VISIBILITY
1133     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
1134
1135     _LIBCPP_INLINE_VISIBILITY
1136     void wait() const {__state_->wait();}
1137     template <class _Rep, class _Period>
1138         _LIBCPP_INLINE_VISIBILITY
1139         future_status
1140         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
1141             {return __state_->wait_for(__rel_time);}
1142     template <class _Clock, class _Duration>
1143         _LIBCPP_INLINE_VISIBILITY
1144         future_status
1145         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
1146             {return __state_->wait_until(__abs_time);}
1147 };
1148
1149 template <class _Rp>
1150 future<_Rp>::future(__assoc_state<_Rp>* __state)
1151     : __state_(__state)
1152 {
1153     if (__state_->__has_future_attached())
1154         __throw_future_error(future_errc::future_already_retrieved);
1155     __state_->__add_shared();
1156     __state_->__set_future_attached();
1157 }
1158
1159 struct __release_shared_count
1160 {
1161     void operator()(__shared_count* p) {p->__release_shared();}
1162 };
1163
1164 template <class _Rp>
1165 future<_Rp>::~future()
1166 {
1167     if (__state_)
1168         __state_->__release_shared();
1169 }
1170
1171 template <class _Rp>
1172 _Rp
1173 future<_Rp>::get()
1174 {
1175     unique_ptr<__shared_count, __release_shared_count> __(__state_);
1176     __assoc_state<_Rp>* __s = __state_;
1177     __state_ = nullptr;
1178     return __s->move();
1179 }
1180
1181 template <class _Rp>
1182 class _LIBCPP_TEMPLATE_VIS future<_Rp&>
1183 {
1184     __assoc_state<_Rp&>* __state_;
1185
1186     explicit future(__assoc_state<_Rp&>* __state);
1187
1188     template <class> friend class promise;
1189     template <class> friend class shared_future;
1190
1191 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1192     template <class _R1, class _Fp>
1193         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
1194     template <class _R1, class _Fp>
1195         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
1196 #else
1197     template <class _R1, class _Fp>
1198         friend future<_R1> __make_deferred_assoc_state(_Fp __f);
1199     template <class _R1, class _Fp>
1200         friend future<_R1> __make_async_assoc_state(_Fp __f);
1201 #endif
1202
1203 public:
1204     _LIBCPP_INLINE_VISIBILITY
1205     future() _NOEXCEPT : __state_(nullptr) {}
1206 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1207     _LIBCPP_INLINE_VISIBILITY
1208     future(future&& __rhs) _NOEXCEPT
1209         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1210     future(const future&) = delete;
1211     future& operator=(const future&) = delete;
1212     _LIBCPP_INLINE_VISIBILITY
1213     future& operator=(future&& __rhs) _NOEXCEPT
1214         {
1215             future(std::move(__rhs)).swap(*this);
1216             return *this;
1217         }
1218 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1219 private:
1220     future(const future&);
1221     future& operator=(const future&);
1222 public:
1223 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1224     ~future();
1225     _LIBCPP_INLINE_VISIBILITY
1226     shared_future<_Rp&> share() _NOEXCEPT;
1227
1228     // retrieving the value
1229     _Rp& get();
1230
1231     _LIBCPP_INLINE_VISIBILITY
1232     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1233
1234     // functions to check state
1235     _LIBCPP_INLINE_VISIBILITY
1236     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
1237
1238     _LIBCPP_INLINE_VISIBILITY
1239     void wait() const {__state_->wait();}
1240     template <class _Rep, class _Period>
1241         _LIBCPP_INLINE_VISIBILITY
1242         future_status
1243         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
1244             {return __state_->wait_for(__rel_time);}
1245     template <class _Clock, class _Duration>
1246         _LIBCPP_INLINE_VISIBILITY
1247         future_status
1248         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
1249             {return __state_->wait_until(__abs_time);}
1250 };
1251
1252 template <class _Rp>
1253 future<_Rp&>::future(__assoc_state<_Rp&>* __state)
1254     : __state_(__state)
1255 {
1256     if (__state_->__has_future_attached())
1257         __throw_future_error(future_errc::future_already_retrieved);
1258     __state_->__add_shared();
1259     __state_->__set_future_attached();
1260 }
1261
1262 template <class _Rp>
1263 future<_Rp&>::~future()
1264 {
1265     if (__state_)
1266         __state_->__release_shared();
1267 }
1268
1269 template <class _Rp>
1270 _Rp&
1271 future<_Rp&>::get()
1272 {
1273     unique_ptr<__shared_count, __release_shared_count> __(__state_);
1274     __assoc_state<_Rp&>* __s = __state_;
1275     __state_ = nullptr;
1276     return __s->copy();
1277 }
1278
1279 template <>
1280 class _LIBCPP_TYPE_VIS future<void>
1281 {
1282     __assoc_sub_state* __state_;
1283
1284     explicit future(__assoc_sub_state* __state);
1285
1286     template <class> friend class promise;
1287     template <class> friend class shared_future;
1288
1289 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1290     template <class _R1, class _Fp>
1291         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
1292     template <class _R1, class _Fp>
1293         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
1294 #else
1295     template <class _R1, class _Fp>
1296         friend future<_R1> __make_deferred_assoc_state(_Fp __f);
1297     template <class _R1, class _Fp>
1298         friend future<_R1> __make_async_assoc_state(_Fp __f);
1299 #endif
1300
1301 public:
1302     _LIBCPP_INLINE_VISIBILITY
1303     future() _NOEXCEPT : __state_(nullptr) {}
1304 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1305     _LIBCPP_INLINE_VISIBILITY
1306     future(future&& __rhs) _NOEXCEPT
1307         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1308     future(const future&) = delete;
1309     future& operator=(const future&) = delete;
1310     _LIBCPP_INLINE_VISIBILITY
1311     future& operator=(future&& __rhs) _NOEXCEPT
1312         {
1313             future(std::move(__rhs)).swap(*this);
1314             return *this;
1315         }
1316 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1317 private:
1318     future(const future&);
1319     future& operator=(const future&);
1320 public:
1321 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1322     ~future();
1323     _LIBCPP_INLINE_VISIBILITY
1324     shared_future<void> share() _NOEXCEPT;
1325
1326     // retrieving the value
1327     void get();
1328
1329     _LIBCPP_INLINE_VISIBILITY
1330     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1331
1332     // functions to check state
1333     _LIBCPP_INLINE_VISIBILITY
1334     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
1335
1336     _LIBCPP_INLINE_VISIBILITY
1337     void wait() const {__state_->wait();}
1338     template <class _Rep, class _Period>
1339         _LIBCPP_INLINE_VISIBILITY
1340         future_status
1341         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
1342             {return __state_->wait_for(__rel_time);}
1343     template <class _Clock, class _Duration>
1344         _LIBCPP_INLINE_VISIBILITY
1345         future_status
1346         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
1347             {return __state_->wait_until(__abs_time);}
1348 };
1349
1350 template <class _Rp>
1351 inline _LIBCPP_INLINE_VISIBILITY
1352 void
1353 swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT
1354 {
1355     __x.swap(__y);
1356 }
1357
1358 // promise<R>
1359
1360 template <class _Callable> class packaged_task;
1361
1362 template <class _Rp>
1363 class _LIBCPP_TEMPLATE_VIS promise
1364 {
1365     __assoc_state<_Rp>* __state_;
1366
1367     _LIBCPP_INLINE_VISIBILITY
1368     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
1369
1370     template <class> friend class packaged_task;
1371 public:
1372     promise();
1373     template <class _Alloc>
1374         promise(allocator_arg_t, const _Alloc& __a);
1375 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1376     _LIBCPP_INLINE_VISIBILITY
1377     promise(promise&& __rhs) _NOEXCEPT
1378         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1379     promise(const promise& __rhs) = delete;
1380 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1381 private:
1382     promise(const promise& __rhs);
1383 public:
1384 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1385     ~promise();
1386
1387     // assignment
1388 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1389     _LIBCPP_INLINE_VISIBILITY
1390     promise& operator=(promise&& __rhs) _NOEXCEPT
1391         {
1392             promise(std::move(__rhs)).swap(*this);
1393             return *this;
1394         }
1395     promise& operator=(const promise& __rhs) = delete;
1396 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1397 private:
1398     promise& operator=(const promise& __rhs);
1399 public:
1400 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1401     _LIBCPP_INLINE_VISIBILITY
1402     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1403
1404     // retrieving the result
1405     future<_Rp> get_future();
1406
1407     // setting the result
1408     void set_value(const _Rp& __r);
1409 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1410     void set_value(_Rp&& __r);
1411 #endif
1412     void set_exception(exception_ptr __p);
1413
1414     // setting the result with deferred notification
1415     void set_value_at_thread_exit(const _Rp& __r);
1416 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1417     void set_value_at_thread_exit(_Rp&& __r);
1418 #endif
1419     void set_exception_at_thread_exit(exception_ptr __p);
1420 };
1421
1422 template <class _Rp>
1423 promise<_Rp>::promise()
1424     : __state_(new __assoc_state<_Rp>)
1425 {
1426 }
1427
1428 template <class _Rp>
1429 template <class _Alloc>
1430 promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0)
1431 {
1432     typedef __assoc_state_alloc<_Rp, _Alloc> _State;
1433     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
1434     typedef __allocator_destructor<_A2> _D2;
1435     _A2 __a(__a0);
1436     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
1437     ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0);
1438     __state_ = _VSTD::addressof(*__hold.release());
1439 }
1440
1441 template <class _Rp>
1442 promise<_Rp>::~promise()
1443 {
1444     if (__state_)
1445     {
1446         if (!__state_->__has_value() && __state_->use_count() > 1)
1447             __state_->set_exception(make_exception_ptr(
1448                       future_error(make_error_code(future_errc::broken_promise))
1449                                                       ));
1450         __state_->__release_shared();
1451     }
1452 }
1453
1454 template <class _Rp>
1455 future<_Rp>
1456 promise<_Rp>::get_future()
1457 {
1458     if (__state_ == nullptr)
1459         __throw_future_error(future_errc::no_state);
1460     return future<_Rp>(__state_);
1461 }
1462
1463 template <class _Rp>
1464 void
1465 promise<_Rp>::set_value(const _Rp& __r)
1466 {
1467     if (__state_ == nullptr)
1468         __throw_future_error(future_errc::no_state);
1469     __state_->set_value(__r);
1470 }
1471
1472 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1473
1474 template <class _Rp>
1475 void
1476 promise<_Rp>::set_value(_Rp&& __r)
1477 {
1478     if (__state_ == nullptr)
1479         __throw_future_error(future_errc::no_state);
1480     __state_->set_value(_VSTD::move(__r));
1481 }
1482
1483 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1484
1485 template <class _Rp>
1486 void
1487 promise<_Rp>::set_exception(exception_ptr __p)
1488 {
1489     _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
1490     if (__state_ == nullptr)
1491         __throw_future_error(future_errc::no_state);
1492     __state_->set_exception(__p);
1493 }
1494
1495 template <class _Rp>
1496 void
1497 promise<_Rp>::set_value_at_thread_exit(const _Rp& __r)
1498 {
1499     if (__state_ == nullptr)
1500         __throw_future_error(future_errc::no_state);
1501     __state_->set_value_at_thread_exit(__r);
1502 }
1503
1504 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1505
1506 template <class _Rp>
1507 void
1508 promise<_Rp>::set_value_at_thread_exit(_Rp&& __r)
1509 {
1510     if (__state_ == nullptr)
1511         __throw_future_error(future_errc::no_state);
1512     __state_->set_value_at_thread_exit(_VSTD::move(__r));
1513 }
1514
1515 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1516
1517 template <class _Rp>
1518 void
1519 promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
1520 {
1521     _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
1522     if (__state_ == nullptr)
1523         __throw_future_error(future_errc::no_state);
1524     __state_->set_exception_at_thread_exit(__p);
1525 }
1526
1527 // promise<R&>
1528
1529 template <class _Rp>
1530 class _LIBCPP_TEMPLATE_VIS promise<_Rp&>
1531 {
1532     __assoc_state<_Rp&>* __state_;
1533
1534     _LIBCPP_INLINE_VISIBILITY
1535     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
1536
1537     template <class> friend class packaged_task;
1538
1539 public:
1540     promise();
1541     template <class _Allocator>
1542         promise(allocator_arg_t, const _Allocator& __a);
1543 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1544     _LIBCPP_INLINE_VISIBILITY
1545     promise(promise&& __rhs) _NOEXCEPT
1546         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1547     promise(const promise& __rhs) = delete;
1548 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1549 private:
1550     promise(const promise& __rhs);
1551 public:
1552 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1553     ~promise();
1554
1555     // assignment
1556 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1557     _LIBCPP_INLINE_VISIBILITY
1558     promise& operator=(promise&& __rhs) _NOEXCEPT
1559         {
1560             promise(std::move(__rhs)).swap(*this);
1561             return *this;
1562         }
1563     promise& operator=(const promise& __rhs) = delete;
1564 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1565 private:
1566     promise& operator=(const promise& __rhs);
1567 public:
1568 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1569     _LIBCPP_INLINE_VISIBILITY
1570     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1571
1572     // retrieving the result
1573     future<_Rp&> get_future();
1574
1575     // setting the result
1576     void set_value(_Rp& __r);
1577     void set_exception(exception_ptr __p);
1578
1579     // setting the result with deferred notification
1580     void set_value_at_thread_exit(_Rp&);
1581     void set_exception_at_thread_exit(exception_ptr __p);
1582 };
1583
1584 template <class _Rp>
1585 promise<_Rp&>::promise()
1586     : __state_(new __assoc_state<_Rp&>)
1587 {
1588 }
1589
1590 template <class _Rp>
1591 template <class _Alloc>
1592 promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0)
1593 {
1594     typedef __assoc_state_alloc<_Rp&, _Alloc> _State;
1595     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
1596     typedef __allocator_destructor<_A2> _D2;
1597     _A2 __a(__a0);
1598     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
1599     ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0);
1600     __state_ = _VSTD::addressof(*__hold.release());
1601 }
1602
1603 template <class _Rp>
1604 promise<_Rp&>::~promise()
1605 {
1606     if (__state_)
1607     {
1608         if (!__state_->__has_value() && __state_->use_count() > 1)
1609             __state_->set_exception(make_exception_ptr(
1610                       future_error(make_error_code(future_errc::broken_promise))
1611                                                       ));
1612         __state_->__release_shared();
1613     }
1614 }
1615
1616 template <class _Rp>
1617 future<_Rp&>
1618 promise<_Rp&>::get_future()
1619 {
1620     if (__state_ == nullptr)
1621         __throw_future_error(future_errc::no_state);
1622     return future<_Rp&>(__state_);
1623 }
1624
1625 template <class _Rp>
1626 void
1627 promise<_Rp&>::set_value(_Rp& __r)
1628 {
1629     if (__state_ == nullptr)
1630         __throw_future_error(future_errc::no_state);
1631     __state_->set_value(__r);
1632 }
1633
1634 template <class _Rp>
1635 void
1636 promise<_Rp&>::set_exception(exception_ptr __p)
1637 {
1638     _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception: received nullptr" );
1639     if (__state_ == nullptr)
1640         __throw_future_error(future_errc::no_state);
1641     __state_->set_exception(__p);
1642 }
1643
1644 template <class _Rp>
1645 void
1646 promise<_Rp&>::set_value_at_thread_exit(_Rp& __r)
1647 {
1648     if (__state_ == nullptr)
1649         __throw_future_error(future_errc::no_state);
1650     __state_->set_value_at_thread_exit(__r);
1651 }
1652
1653 template <class _Rp>
1654 void
1655 promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p)
1656 {
1657     _LIBCPP_ASSERT( __p != nullptr, "promise::set_exception_at_thread_exit: received nullptr" );
1658     if (__state_ == nullptr)
1659         __throw_future_error(future_errc::no_state);
1660     __state_->set_exception_at_thread_exit(__p);
1661 }
1662
1663 // promise<void>
1664
1665 template <>
1666 class _LIBCPP_TYPE_VIS promise<void>
1667 {
1668     __assoc_sub_state* __state_;
1669
1670     _LIBCPP_INLINE_VISIBILITY
1671     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
1672
1673     template <class> friend class packaged_task;
1674
1675 public:
1676     promise();
1677     template <class _Allocator>
1678         _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS
1679         promise(allocator_arg_t, const _Allocator& __a);
1680 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1681     _LIBCPP_INLINE_VISIBILITY
1682     promise(promise&& __rhs) _NOEXCEPT
1683         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1684     promise(const promise& __rhs) = delete;
1685 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1686 private:
1687     promise(const promise& __rhs);
1688 public:
1689 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1690     ~promise();
1691
1692     // assignment
1693 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1694     _LIBCPP_INLINE_VISIBILITY
1695     promise& operator=(promise&& __rhs) _NOEXCEPT
1696         {
1697             promise(std::move(__rhs)).swap(*this);
1698             return *this;
1699         }
1700     promise& operator=(const promise& __rhs) = delete;
1701 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1702 private:
1703     promise& operator=(const promise& __rhs);
1704 public:
1705 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1706     _LIBCPP_INLINE_VISIBILITY
1707     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1708
1709     // retrieving the result
1710     future<void> get_future();
1711
1712     // setting the result
1713     void set_value();
1714     void set_exception(exception_ptr __p);
1715
1716     // setting the result with deferred notification
1717     void set_value_at_thread_exit();
1718     void set_exception_at_thread_exit(exception_ptr __p);
1719 };
1720
1721 template <class _Alloc>
1722 promise<void>::promise(allocator_arg_t, const _Alloc& __a0)
1723 {
1724     typedef __assoc_sub_state_alloc<_Alloc> _State;
1725     typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;
1726     typedef __allocator_destructor<_A2> _D2;
1727     _A2 __a(__a0);
1728     unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
1729     ::new(static_cast<void*>(_VSTD::addressof(*__hold.get()))) _State(__a0);
1730     __state_ = _VSTD::addressof(*__hold.release());
1731 }
1732
1733 template <class _Rp>
1734 inline _LIBCPP_INLINE_VISIBILITY
1735 void
1736 swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT
1737 {
1738     __x.swap(__y);
1739 }
1740
1741 template <class _Rp, class _Alloc>
1742     struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc>
1743         : public true_type {};
1744
1745 #ifndef _LIBCPP_HAS_NO_VARIADICS
1746
1747 // packaged_task
1748
1749 template<class _Fp> class __packaged_task_base;
1750
1751 template<class _Rp, class ..._ArgTypes>
1752 class __packaged_task_base<_Rp(_ArgTypes...)>
1753 {
1754     __packaged_task_base(const __packaged_task_base&);
1755     __packaged_task_base& operator=(const __packaged_task_base&);
1756 public:
1757     _LIBCPP_INLINE_VISIBILITY
1758     __packaged_task_base() {}
1759     _LIBCPP_INLINE_VISIBILITY
1760     virtual ~__packaged_task_base() {}
1761     virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
1762     virtual void destroy() = 0;
1763     virtual void destroy_deallocate() = 0;
1764     virtual _Rp operator()(_ArgTypes&& ...) = 0;
1765 };
1766
1767 template<class _FD, class _Alloc, class _FB> class __packaged_task_func;
1768
1769 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1770 class __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>
1771     : public  __packaged_task_base<_Rp(_ArgTypes...)>
1772 {
1773     __compressed_pair<_Fp, _Alloc> __f_;
1774 public:
1775     _LIBCPP_INLINE_VISIBILITY
1776     explicit __packaged_task_func(const _Fp& __f) : __f_(__f) {}
1777     _LIBCPP_INLINE_VISIBILITY
1778     explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f)) {}
1779     _LIBCPP_INLINE_VISIBILITY
1780     __packaged_task_func(const _Fp& __f, const _Alloc& __a)
1781         : __f_(__f, __a) {}
1782     _LIBCPP_INLINE_VISIBILITY
1783     __packaged_task_func(_Fp&& __f, const _Alloc& __a)
1784         : __f_(_VSTD::move(__f), __a) {}
1785     virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;
1786     virtual void destroy();
1787     virtual void destroy_deallocate();
1788     virtual _Rp operator()(_ArgTypes&& ... __args);
1789 };
1790
1791 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1792 void
1793 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
1794                               __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT
1795 {
1796     ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
1797 }
1798
1799 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1800 void
1801 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy()
1802 {
1803     __f_.~__compressed_pair<_Fp, _Alloc>();
1804 }
1805
1806 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1807 void
1808 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate()
1809 {
1810     typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap;
1811     typedef allocator_traits<_Ap> _ATraits;
1812     typedef pointer_traits<typename _ATraits::pointer> _PTraits;
1813     _Ap __a(__f_.second());
1814     __f_.~__compressed_pair<_Fp, _Alloc>();
1815     __a.deallocate(_PTraits::pointer_to(*this), 1);
1816 }
1817
1818 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1819 _Rp
1820 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
1821 {
1822     return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
1823 }
1824
1825 template <class _Callable> class __packaged_task_function;
1826
1827 template<class _Rp, class ..._ArgTypes>
1828 class __packaged_task_function<_Rp(_ArgTypes...)>
1829 {
1830     typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
1831     typename aligned_storage<3*sizeof(void*)>::type __buf_;
1832     __base* __f_;
1833
1834 public:
1835     typedef _Rp result_type;
1836
1837     // construct/copy/destroy:
1838     _LIBCPP_INLINE_VISIBILITY
1839     __packaged_task_function() _NOEXCEPT : __f_(nullptr) {}
1840     template<class _Fp>
1841       __packaged_task_function(_Fp&& __f);
1842     template<class _Fp, class _Alloc>
1843       __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f);
1844
1845     __packaged_task_function(__packaged_task_function&&) _NOEXCEPT;
1846     __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT;
1847
1848     __packaged_task_function(const __packaged_task_function&) =  delete;
1849     __packaged_task_function& operator=(const __packaged_task_function&) =  delete;
1850
1851     ~__packaged_task_function();
1852
1853     void swap(__packaged_task_function&) _NOEXCEPT;
1854
1855     _LIBCPP_INLINE_VISIBILITY
1856     _Rp operator()(_ArgTypes...) const;
1857 };
1858
1859 template<class _Rp, class ..._ArgTypes>
1860 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT
1861 {
1862     if (__f.__f_ == nullptr)
1863         __f_ = nullptr;
1864     else if (__f.__f_ == (__base*)&__f.__buf_)
1865     {
1866         __f_ = (__base*)&__buf_;
1867         __f.__f_->__move_to(__f_);
1868     }
1869     else
1870     {
1871         __f_ = __f.__f_;
1872         __f.__f_ = nullptr;
1873     }
1874 }
1875
1876 template<class _Rp, class ..._ArgTypes>
1877 template <class _Fp>
1878 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f)
1879     : __f_(nullptr)
1880 {
1881     typedef typename remove_reference<typename decay<_Fp>::type>::type _FR;
1882     typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;
1883     if (sizeof(_FF) <= sizeof(__buf_))
1884     {
1885         __f_ = (__base*)&__buf_;
1886         ::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
1887     }
1888     else
1889     {
1890         typedef allocator<_FF> _Ap;
1891         _Ap __a;
1892         typedef __allocator_destructor<_Ap> _Dp;
1893         unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1894         ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a));
1895         __f_ = __hold.release();
1896     }
1897 }
1898
1899 template<class _Rp, class ..._ArgTypes>
1900 template <class _Fp, class _Alloc>
1901 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(
1902                                   allocator_arg_t, const _Alloc& __a0, _Fp&& __f)
1903     : __f_(nullptr)
1904 {
1905     typedef typename remove_reference<typename decay<_Fp>::type>::type _FR;
1906     typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;
1907     if (sizeof(_FF) <= sizeof(__buf_))
1908     {
1909         __f_ = (__base*)&__buf_;
1910         ::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
1911     }
1912     else
1913     {
1914         typedef typename __allocator_traits_rebind<_Alloc, _FF>::type _Ap;
1915         _Ap __a(__a0);
1916         typedef __allocator_destructor<_Ap> _Dp;
1917         unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1918         ::new (static_cast<void*>(_VSTD::addressof(*__hold.get())))
1919             _FF(_VSTD::forward<_Fp>(__f), _Alloc(__a));
1920         __f_ = _VSTD::addressof(*__hold.release());
1921     }
1922 }
1923
1924 template<class _Rp, class ..._ArgTypes>
1925 __packaged_task_function<_Rp(_ArgTypes...)>&
1926 __packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT
1927 {
1928     if (__f_ == (__base*)&__buf_)
1929         __f_->destroy();
1930     else if (__f_)
1931         __f_->destroy_deallocate();
1932     __f_ = nullptr;
1933     if (__f.__f_ == nullptr)
1934         __f_ = nullptr;
1935     else if (__f.__f_ == (__base*)&__f.__buf_)
1936     {
1937         __f_ = (__base*)&__buf_;
1938         __f.__f_->__move_to(__f_);
1939     }
1940     else
1941     {
1942         __f_ = __f.__f_;
1943         __f.__f_ = nullptr;
1944     }
1945     return *this;
1946 }
1947
1948 template<class _Rp, class ..._ArgTypes>
1949 __packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function()
1950 {
1951     if (__f_ == (__base*)&__buf_)
1952         __f_->destroy();
1953     else if (__f_)
1954         __f_->destroy_deallocate();
1955 }
1956
1957 template<class _Rp, class ..._ArgTypes>
1958 void
1959 __packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT
1960 {
1961     if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
1962     {
1963         typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
1964         __base* __t = (__base*)&__tempbuf;
1965         __f_->__move_to(__t);
1966         __f_->destroy();
1967         __f_ = nullptr;
1968         __f.__f_->__move_to((__base*)&__buf_);
1969         __f.__f_->destroy();
1970         __f.__f_ = nullptr;
1971         __f_ = (__base*)&__buf_;
1972         __t->__move_to((__base*)&__f.__buf_);
1973         __t->destroy();
1974         __f.__f_ = (__base*)&__f.__buf_;
1975     }
1976     else if (__f_ == (__base*)&__buf_)
1977     {
1978         __f_->__move_to((__base*)&__f.__buf_);
1979         __f_->destroy();
1980         __f_ = __f.__f_;
1981         __f.__f_ = (__base*)&__f.__buf_;
1982     }
1983     else if (__f.__f_ == (__base*)&__f.__buf_)
1984     {
1985         __f.__f_->__move_to((__base*)&__buf_);
1986         __f.__f_->destroy();
1987         __f.__f_ = __f_;
1988         __f_ = (__base*)&__buf_;
1989     }
1990     else
1991         _VSTD::swap(__f_, __f.__f_);
1992 }
1993
1994 template<class _Rp, class ..._ArgTypes>
1995 inline
1996 _Rp
1997 __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
1998 {
1999     return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
2000 }
2001
2002 template<class _Rp, class ..._ArgTypes>
2003 class _LIBCPP_TEMPLATE_VIS packaged_task<_Rp(_ArgTypes...)>
2004 {
2005 public:
2006     typedef _Rp result_type; // extension
2007
2008 private:
2009     __packaged_task_function<result_type(_ArgTypes...)> __f_;
2010     promise<result_type>                                __p_;
2011
2012 public:
2013     // construction and destruction
2014     _LIBCPP_INLINE_VISIBILITY
2015     packaged_task() _NOEXCEPT : __p_(nullptr) {}
2016     template <class _Fp,
2017               class = typename enable_if
2018               <
2019                   !is_same<
2020                       typename decay<_Fp>::type,
2021                       packaged_task
2022                       >::value
2023                   >::type
2024              >
2025         _LIBCPP_INLINE_VISIBILITY
2026         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
2027     template <class _Fp, class _Allocator,
2028               class = typename enable_if
2029               <
2030                   !is_same<
2031                       typename decay<_Fp>::type,
2032                       packaged_task
2033                       >::value
2034                   >::type
2035               >
2036         _LIBCPP_INLINE_VISIBILITY
2037         packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
2038              : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
2039                __p_(allocator_arg, __a) {}
2040     // ~packaged_task() = default;
2041
2042     // no copy
2043     packaged_task(const packaged_task&) = delete;
2044     packaged_task& operator=(const packaged_task&) = delete;
2045
2046     // move support
2047     _LIBCPP_INLINE_VISIBILITY
2048     packaged_task(packaged_task&& __other) _NOEXCEPT
2049         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
2050     _LIBCPP_INLINE_VISIBILITY
2051     packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
2052     {
2053         __f_ = _VSTD::move(__other.__f_);
2054         __p_ = _VSTD::move(__other.__p_);
2055         return *this;
2056     }
2057     _LIBCPP_INLINE_VISIBILITY
2058     void swap(packaged_task& __other) _NOEXCEPT
2059     {
2060         __f_.swap(__other.__f_);
2061         __p_.swap(__other.__p_);
2062     }
2063
2064     _LIBCPP_INLINE_VISIBILITY
2065     bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
2066
2067     // result retrieval
2068     _LIBCPP_INLINE_VISIBILITY
2069     future<result_type> get_future() {return __p_.get_future();}
2070
2071     // execution
2072     void operator()(_ArgTypes... __args);
2073     void make_ready_at_thread_exit(_ArgTypes... __args);
2074
2075     void reset();
2076 };
2077
2078 template<class _Rp, class ..._ArgTypes>
2079 void
2080 packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args)
2081 {
2082     if (__p_.__state_ == nullptr)
2083         __throw_future_error(future_errc::no_state);
2084     if (__p_.__state_->__has_value())
2085         __throw_future_error(future_errc::promise_already_satisfied);
2086 #ifndef _LIBCPP_NO_EXCEPTIONS
2087     try
2088     {
2089 #endif  // _LIBCPP_NO_EXCEPTIONS
2090         __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
2091 #ifndef _LIBCPP_NO_EXCEPTIONS
2092     }
2093     catch (...)
2094     {
2095         __p_.set_exception(current_exception());
2096     }
2097 #endif  // _LIBCPP_NO_EXCEPTIONS
2098 }
2099
2100 template<class _Rp, class ..._ArgTypes>
2101 void
2102 packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
2103 {
2104     if (__p_.__state_ == nullptr)
2105         __throw_future_error(future_errc::no_state);
2106     if (__p_.__state_->__has_value())
2107         __throw_future_error(future_errc::promise_already_satisfied);
2108 #ifndef _LIBCPP_NO_EXCEPTIONS
2109     try
2110     {
2111 #endif  // _LIBCPP_NO_EXCEPTIONS
2112         __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
2113 #ifndef _LIBCPP_NO_EXCEPTIONS
2114     }
2115     catch (...)
2116     {
2117         __p_.set_exception_at_thread_exit(current_exception());
2118     }
2119 #endif  // _LIBCPP_NO_EXCEPTIONS
2120 }
2121
2122 template<class _Rp, class ..._ArgTypes>
2123 void
2124 packaged_task<_Rp(_ArgTypes...)>::reset()
2125 {
2126     if (!valid())
2127         __throw_future_error(future_errc::no_state);
2128     __p_ = promise<result_type>();
2129 }
2130
2131 template<class ..._ArgTypes>
2132 class _LIBCPP_TEMPLATE_VIS packaged_task<void(_ArgTypes...)>
2133 {
2134 public:
2135     typedef void result_type; // extension
2136
2137 private:
2138     __packaged_task_function<result_type(_ArgTypes...)> __f_;
2139     promise<result_type>                                __p_;
2140
2141 public:
2142     // construction and destruction
2143     _LIBCPP_INLINE_VISIBILITY
2144     packaged_task() _NOEXCEPT : __p_(nullptr) {}
2145     template <class _Fp,
2146               class = typename enable_if
2147               <
2148                   !is_same<
2149                       typename decay<_Fp>::type,
2150                       packaged_task
2151                       >::value
2152                   >::type
2153               >
2154         _LIBCPP_INLINE_VISIBILITY
2155         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
2156     template <class _Fp, class _Allocator,
2157               class = typename enable_if
2158               <
2159                   !is_same<
2160                       typename decay<_Fp>::type,
2161                       packaged_task
2162                       >::value
2163                   >::type
2164               >
2165         _LIBCPP_INLINE_VISIBILITY
2166         packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
2167              : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
2168                __p_(allocator_arg, __a) {}
2169     // ~packaged_task() = default;
2170
2171     // no copy
2172     packaged_task(const packaged_task&) = delete;
2173     packaged_task& operator=(const packaged_task&) = delete;
2174
2175     // move support
2176     _LIBCPP_INLINE_VISIBILITY
2177     packaged_task(packaged_task&& __other) _NOEXCEPT
2178         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
2179     _LIBCPP_INLINE_VISIBILITY
2180     packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
2181     {
2182         __f_ = _VSTD::move(__other.__f_);
2183         __p_ = _VSTD::move(__other.__p_);
2184         return *this;
2185     }
2186     _LIBCPP_INLINE_VISIBILITY
2187     void swap(packaged_task& __other) _NOEXCEPT
2188     {
2189         __f_.swap(__other.__f_);
2190         __p_.swap(__other.__p_);
2191     }
2192
2193     _LIBCPP_INLINE_VISIBILITY
2194     bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
2195
2196     // result retrieval
2197     _LIBCPP_INLINE_VISIBILITY
2198     future<result_type> get_future() {return __p_.get_future();}
2199
2200     // execution
2201     void operator()(_ArgTypes... __args);
2202     void make_ready_at_thread_exit(_ArgTypes... __args);
2203
2204     void reset();
2205 };
2206
2207 template<class ..._ArgTypes>
2208 void
2209 packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
2210 {
2211     if (__p_.__state_ == nullptr)
2212         __throw_future_error(future_errc::no_state);
2213     if (__p_.__state_->__has_value())
2214         __throw_future_error(future_errc::promise_already_satisfied);
2215 #ifndef _LIBCPP_NO_EXCEPTIONS
2216     try
2217     {
2218 #endif  // _LIBCPP_NO_EXCEPTIONS
2219         __f_(_VSTD::forward<_ArgTypes>(__args)...);
2220         __p_.set_value();
2221 #ifndef _LIBCPP_NO_EXCEPTIONS
2222     }
2223     catch (...)
2224     {
2225         __p_.set_exception(current_exception());
2226     }
2227 #endif  // _LIBCPP_NO_EXCEPTIONS
2228 }
2229
2230 template<class ..._ArgTypes>
2231 void
2232 packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
2233 {
2234     if (__p_.__state_ == nullptr)
2235         __throw_future_error(future_errc::no_state);
2236     if (__p_.__state_->__has_value())
2237         __throw_future_error(future_errc::promise_already_satisfied);
2238 #ifndef _LIBCPP_NO_EXCEPTIONS
2239     try
2240     {
2241 #endif  // _LIBCPP_NO_EXCEPTIONS
2242         __f_(_VSTD::forward<_ArgTypes>(__args)...);
2243         __p_.set_value_at_thread_exit();
2244 #ifndef _LIBCPP_NO_EXCEPTIONS
2245     }
2246     catch (...)
2247     {
2248         __p_.set_exception_at_thread_exit(current_exception());
2249     }
2250 #endif  // _LIBCPP_NO_EXCEPTIONS
2251 }
2252
2253 template<class ..._ArgTypes>
2254 void
2255 packaged_task<void(_ArgTypes...)>::reset()
2256 {
2257     if (!valid())
2258         __throw_future_error(future_errc::no_state);
2259     __p_ = promise<result_type>();
2260 }
2261
2262 template <class _Callable>
2263 inline _LIBCPP_INLINE_VISIBILITY
2264 void
2265 swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) _NOEXCEPT
2266 {
2267     __x.swap(__y);
2268 }
2269
2270 template <class _Callable, class _Alloc>
2271 struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>
2272     : public true_type {};
2273
2274 template <class _Rp, class _Fp>
2275 future<_Rp>
2276 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2277 __make_deferred_assoc_state(_Fp&& __f)
2278 #else
2279 __make_deferred_assoc_state(_Fp __f)
2280 #endif
2281 {
2282     unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count>
2283         __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
2284     return future<_Rp>(__h.get());
2285 }
2286
2287 template <class _Rp, class _Fp>
2288 future<_Rp>
2289 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2290 __make_async_assoc_state(_Fp&& __f)
2291 #else
2292 __make_async_assoc_state(_Fp __f)
2293 #endif
2294 {
2295     unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count>
2296         __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
2297     _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
2298     return future<_Rp>(__h.get());
2299 }
2300
2301 template <class _Fp, class... _Args>
2302 class __async_func
2303 {
2304     tuple<_Fp, _Args...> __f_;
2305
2306 public:
2307     typedef typename __invoke_of<_Fp, _Args...>::type _Rp;
2308
2309     _LIBCPP_INLINE_VISIBILITY
2310     explicit __async_func(_Fp&& __f, _Args&&... __args)
2311         : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}
2312
2313     _LIBCPP_INLINE_VISIBILITY
2314     __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {}
2315
2316     _Rp operator()()
2317     {
2318         typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index;
2319         return __execute(_Index());
2320     }
2321 private:
2322     template <size_t ..._Indices>
2323     _Rp
2324     __execute(__tuple_indices<_Indices...>)
2325     {
2326         return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
2327     }
2328 };
2329
2330 inline _LIBCPP_INLINE_VISIBILITY bool __does_policy_contain(launch __policy, launch __value )
2331 { return (int(__policy) & int(__value)) != 0; }
2332
2333 template <class _Fp, class... _Args>
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 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 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