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     broken_promise,
  23     future_already_retrieved,
  24     promise_already_satisfied,
  25     no_state
  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
  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();
 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();
 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();
 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<F(Args...)>::type>
 313   async(F&& f, Args&&... args);
 314
 315 template <class F, class... Args>
 316   future<typename result_of<F(Args...)>::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;
 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         explicit 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 _LIBCPP_BEGIN_NAMESPACE_STD
 378
 379 //enum class future_errc
 380 _LIBCPP_DECLARE_STRONG_ENUM(future_errc)
 381 {
 382     broken_promise,
 383     future_already_retrieved,
 384     promise_already_satisfied,
 385     no_state
 386 };
 387 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc)
 388
 389 template <>
 390 struct _LIBCPP_TYPE_VIS is_error_code_enum<future_errc> : public true_type {};
 391
 392 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 393 template <>
 394 struct _LIBCPP_TYPE_VIS is_error_code_enum<future_errc::__lx> : public true_type { };
 395 #endif
 396
 397 //enum class launch
 398 _LIBCPP_DECLARE_STRONG_ENUM(launch)
 399 {
 400     async = 1,
 401     deferred = 2,
 402     any = async | deferred
 403 };
 404 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)
 405
 406 #ifndef _LIBCPP_HAS_NO_STRONG_ENUMS
 407
 408 #ifdef _LIBCXX_UNDERLYING_TYPE
 409 typedef underlying_type<launch>::type __launch_underlying_type;
 410 #else
 411 typedef int __launch_underlying_type;
 412 #endif
 413
 414 inline _LIBCPP_INLINE_VISIBILITY
 415 _LIBCPP_CONSTEXPR
 416 launch
 417 operator&(launch __x, launch __y)
 418 {
 419     return static_cast<launch>(static_cast<__launch_underlying_type>(__x) &
 420                                static_cast<__launch_underlying_type>(__y));
 421 }
 422
 423 inline _LIBCPP_INLINE_VISIBILITY
 424 _LIBCPP_CONSTEXPR
 425 launch
 426 operator|(launch __x, launch __y)
 427 {
 428     return static_cast<launch>(static_cast<__launch_underlying_type>(__x) |
 429                                static_cast<__launch_underlying_type>(__y));
 430 }
 431
 432 inline _LIBCPP_INLINE_VISIBILITY
 433 _LIBCPP_CONSTEXPR
 434 launch
 435 operator^(launch __x, launch __y)
 436 {
 437     return static_cast<launch>(static_cast<__launch_underlying_type>(__x) ^
 438                                static_cast<__launch_underlying_type>(__y));
 439 }
 440
 441 inline _LIBCPP_INLINE_VISIBILITY
 442 _LIBCPP_CONSTEXPR
 443 launch
 444 operator~(launch __x)
 445 {
 446     return static_cast<launch>(~static_cast<__launch_underlying_type>(__x) & 3);
 447 }
 448
 449 inline _LIBCPP_INLINE_VISIBILITY
 450 launch&
 451 operator&=(launch& __x, launch __y)
 452 {
 453     __x = __x & __y; return __x;
 454 }
 455
 456 inline _LIBCPP_INLINE_VISIBILITY
 457 launch&
 458 operator|=(launch& __x, launch __y)
 459 {
 460     __x = __x | __y; return __x;
 461 }
 462
 463 inline _LIBCPP_INLINE_VISIBILITY
 464 launch&
 465 operator^=(launch& __x, launch __y)
 466 {
 467     __x = __x ^ __y; return __x;
 468 }
 469
 470 #endif  // !_LIBCPP_HAS_NO_STRONG_ENUMS
 471
 472 //enum class future_status
 473 _LIBCPP_DECLARE_STRONG_ENUM(future_status)
 474 {
 475     ready,
 476     timeout,
 477     deferred
 478 };
 479 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)
 480
 481 _LIBCPP_FUNC_VIS
 482 const error_category& future_category() _NOEXCEPT;
 483
 484 inline _LIBCPP_INLINE_VISIBILITY
 485 error_code
 486 make_error_code(future_errc __e) _NOEXCEPT
 487 {
 488     return error_code(static_cast<int>(__e), future_category());
 489 }
 490
 491 inline _LIBCPP_INLINE_VISIBILITY
 492 error_condition
 493 make_error_condition(future_errc __e) _NOEXCEPT
 494 {
 495     return error_condition(static_cast<int>(__e), future_category());
 496 }
 497
 498 class _LIBCPP_EXCEPTION_ABI future_error
 499     : public logic_error
 500 {
 501     error_code __ec_;
 502 public:
 503     future_error(error_code __ec);
 504
 505     _LIBCPP_INLINE_VISIBILITY
 506     const error_code& code() const _NOEXCEPT {return __ec_;}
 507
 508     virtual ~future_error() _NOEXCEPT;
 509 };
 510
 511 class __assoc_sub_state
 512     : public __shared_count
 513 {
 514 protected:
 515     exception_ptr __exception_;
 516     mutable mutex __mut_;
 517     mutable condition_variable __cv_;
 518     unsigned __state_;
 519
 520     virtual void __on_zero_shared() _NOEXCEPT;
 521     void __sub_wait(unique_lock<mutex>& __lk);
 522 public:
 523     enum
 524     {
 525         __constructed = 1,
 526         __future_attached = 2,
 527         ready = 4,
 528         deferred = 8
 529     };
 530
 531     _LIBCPP_INLINE_VISIBILITY
 532     __assoc_sub_state() : __state_(0) {}
 533
 534     _LIBCPP_INLINE_VISIBILITY
 535     bool __has_value() const
 536         {return (__state_ & __constructed) || (__exception_ != nullptr);}
 537
 538     _LIBCPP_INLINE_VISIBILITY
 539     void __set_future_attached()
 540     {
 541         lock_guard<mutex> __lk(__mut_);
 542         __state_ |= __future_attached;
 543     }
 544     _LIBCPP_INLINE_VISIBILITY
 545     bool __has_future_attached() const {return __state_ & __future_attached;}
 546
 547     _LIBCPP_INLINE_VISIBILITY
 548     void __set_deferred() {__state_ |= deferred;}
 549
 550     void __make_ready();
 551     _LIBCPP_INLINE_VISIBILITY
 552     bool __is_ready() const {return __state_ & ready;}
 553
 554     void set_value();
 555     void set_value_at_thread_exit();
 556
 557     void set_exception(exception_ptr __p);
 558     void set_exception_at_thread_exit(exception_ptr __p);
 559
 560     void copy();
 561
 562     void wait();
 563     template <class _Rep, class _Period>
 564         future_status
 565         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;
 566     template <class _Clock, class _Duration>
 567         future_status
 568         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;
 569
 570     virtual void __execute();
 571 };
 572
 573 template <class _Clock, class _Duration>
 574 future_status
 575 __assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
 576 {
 577     unique_lock<mutex> __lk(__mut_);
 578     if (__state_ & deferred)
 579         return future_status::deferred;
 580     while (!(__state_ & ready) && _Clock::now() < __abs_time)
 581         __cv_.wait_until(__lk, __abs_time);
 582     if (__state_ & ready)
 583         return future_status::ready;
 584     return future_status::timeout;
 585 }
 586
 587 template <class _Rep, class _Period>
 588 inline _LIBCPP_INLINE_VISIBILITY
 589 future_status
 590 __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 591 {
 592     return wait_until(chrono::steady_clock::now() + __rel_time);
 593 }
 594
 595 template <class _Rp>
 596 class __assoc_state
 597     : public __assoc_sub_state
 598 {
 599     typedef __assoc_sub_state base;
 600     typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;
 601 protected:
 602     _Up __value_;
 603
 604     virtual void __on_zero_shared() _NOEXCEPT;
 605 public:
 606
 607     template <class _Arg>
 608 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 609         void set_value(_Arg&& __arg);
 610 #else
 611         void set_value(_Arg& __arg);
 612 #endif
 613
 614     template <class _Arg>
 615 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 616         void set_value_at_thread_exit(_Arg&& __arg);
 617 #else
 618         void set_value_at_thread_exit(_Arg& __arg);
 619 #endif
 620
 621     _Rp move();
 622     typename add_lvalue_reference<_Rp>::type copy();
 623 };
 624
 625 template <class _Rp>
 626 void
 627 __assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT
 628 {
 629     if (this->__state_ & base::__constructed)
 630         reinterpret_cast<_Rp*>(&__value_)->~_Rp();
 631     delete this;
 632 }
 633
 634 template <class _Rp>
 635 template <class _Arg>
 636 void
 637 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 638 __assoc_state<_Rp>::set_value(_Arg&& __arg)
 639 #else
 640 __assoc_state<_Rp>::set_value(_Arg& __arg)
 641 #endif
 642 {
 643     unique_lock<mutex> __lk(this->__mut_);
 644 #ifndef _LIBCPP_NO_EXCEPTIONS
 645     if (this->__has_value())
 646         throw future_error(make_error_code(future_errc::promise_already_satisfied));
 647 #endif
 648     ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
 649     this->__state_ |= base::__constructed | base::ready;
 650     __lk.unlock();
 651     __cv_.notify_all();
 652 }
 653
 654 template <class _Rp>
 655 template <class _Arg>
 656 void
 657 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 658 __assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg)
 659 #else
 660 __assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg)
 661 #endif
 662 {
 663     unique_lock<mutex> __lk(this->__mut_);
 664 #ifndef _LIBCPP_NO_EXCEPTIONS
 665     if (this->__has_value())
 666         throw future_error(make_error_code(future_errc::promise_already_satisfied));
 667 #endif
 668     ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg));
 669     this->__state_ |= base::__constructed;
 670     __thread_local_data()->__make_ready_at_thread_exit(this);
 671     __lk.unlock();
 672 }
 673
 674 template <class _Rp>
 675 _Rp
 676 __assoc_state<_Rp>::move()
 677 {
 678     unique_lock<mutex> __lk(this->__mut_);
 679     this->__sub_wait(__lk);
 680     if (this->__exception_ != nullptr)
 681         rethrow_exception(this->__exception_);
 682     return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_));
 683 }
 684
 685 template <class _Rp>
 686 typename add_lvalue_reference<_Rp>::type
 687 __assoc_state<_Rp>::copy()
 688 {
 689     unique_lock<mutex> __lk(this->__mut_);
 690     this->__sub_wait(__lk);
 691     if (this->__exception_ != nullptr)
 692         rethrow_exception(this->__exception_);
 693     return *reinterpret_cast<_Rp*>(&__value_);
 694 }
 695
 696 template <class _Rp>
 697 class __assoc_state<_Rp&>
 698     : public __assoc_sub_state
 699 {
 700     typedef __assoc_sub_state base;
 701     typedef _Rp* _Up;
 702 protected:
 703     _Up __value_;
 704
 705     virtual void __on_zero_shared() _NOEXCEPT;
 706 public:
 707
 708     void set_value(_Rp& __arg);
 709     void set_value_at_thread_exit(_Rp& __arg);
 710
 711     _Rp& copy();
 712 };
 713
 714 template <class _Rp>
 715 void
 716 __assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT
 717 {
 718     delete this;
 719 }
 720
 721 template <class _Rp>
 722 void
 723 __assoc_state<_Rp&>::set_value(_Rp& __arg)
 724 {
 725     unique_lock<mutex> __lk(this->__mut_);
 726 #ifndef _LIBCPP_NO_EXCEPTIONS
 727     if (this->__has_value())
 728         throw future_error(make_error_code(future_errc::promise_already_satisfied));
 729 #endif
 730     __value_ = &__arg;
 731     this->__state_ |= base::__constructed | base::ready;
 732     __lk.unlock();
 733     __cv_.notify_all();
 734 }
 735
 736 template <class _Rp>
 737 void
 738 __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg)
 739 {
 740     unique_lock<mutex> __lk(this->__mut_);
 741 #ifndef _LIBCPP_NO_EXCEPTIONS
 742     if (this->__has_value())
 743         throw future_error(make_error_code(future_errc::promise_already_satisfied));
 744 #endif
 745     __value_ = &__arg;
 746     this->__state_ |= base::__constructed;
 747     __thread_local_data()->__make_ready_at_thread_exit(this);
 748     __lk.unlock();
 749 }
 750
 751 template <class _Rp>
 752 _Rp&
 753 __assoc_state<_Rp&>::copy()
 754 {
 755     unique_lock<mutex> __lk(this->__mut_);
 756     this->__sub_wait(__lk);
 757     if (this->__exception_ != nullptr)
 758         rethrow_exception(this->__exception_);
 759     return *__value_;
 760 }
 761
 762 template <class _Rp, class _Alloc>
 763 class __assoc_state_alloc
 764     : public __assoc_state<_Rp>
 765 {
 766     typedef __assoc_state<_Rp> base;
 767     _Alloc __alloc_;
 768
 769     virtual void __on_zero_shared() _NOEXCEPT;
 770 public:
 771     _LIBCPP_INLINE_VISIBILITY
 772     explicit __assoc_state_alloc(const _Alloc& __a)
 773         : __alloc_(__a) {}
 774 };
 775
 776 template <class _Rp, class _Alloc>
 777 void
 778 __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT
 779 {
 780     if (this->__state_ & base::__constructed)
 781         reinterpret_cast<_Rp*>(&this->__value_)->~_Rp();
 782     typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_);
 783     this->~__assoc_state_alloc();
 784     __a.deallocate(this, 1);
 785 }
 786
 787 template <class _Rp, class _Alloc>
 788 class __assoc_state_alloc<_Rp&, _Alloc>
 789     : public __assoc_state<_Rp&>
 790 {
 791     typedef __assoc_state<_Rp&> base;
 792     _Alloc __alloc_;
 793
 794     virtual void __on_zero_shared() _NOEXCEPT;
 795 public:
 796     _LIBCPP_INLINE_VISIBILITY
 797     explicit __assoc_state_alloc(const _Alloc& __a)
 798         : __alloc_(__a) {}
 799 };
 800
 801 template <class _Rp, class _Alloc>
 802 void
 803 __assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT
 804 {
 805     typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_);
 806     this->~__assoc_state_alloc();
 807     __a.deallocate(this, 1);
 808 }
 809
 810 template <class _Alloc>
 811 class __assoc_sub_state_alloc
 812     : public __assoc_sub_state
 813 {
 814     typedef __assoc_sub_state base;
 815     _Alloc __alloc_;
 816
 817     virtual void __on_zero_shared() _NOEXCEPT;
 818 public:
 819     _LIBCPP_INLINE_VISIBILITY
 820     explicit __assoc_sub_state_alloc(const _Alloc& __a)
 821         : __alloc_(__a) {}
 822 };
 823
 824 template <class _Alloc>
 825 void
 826 __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT
 827 {
 828     typename _Alloc::template rebind<__assoc_sub_state_alloc>::other __a(__alloc_);
 829     this->~__assoc_sub_state_alloc();
 830     __a.deallocate(this, 1);
 831 }
 832
 833 template <class _Rp, class _Fp>
 834 class __deferred_assoc_state
 835     : public __assoc_state<_Rp>
 836 {
 837     typedef __assoc_state<_Rp> base;
 838
 839     _Fp __func_;
 840
 841 public:
 842 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 843     explicit __deferred_assoc_state(_Fp&& __f);
 844 #endif
 845
 846     virtual void __execute();
 847 };
 848
 849 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 850
 851 template <class _Rp, class _Fp>
 852 inline _LIBCPP_INLINE_VISIBILITY
 853 __deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f)
 854     : __func_(_VSTD::forward<_Fp>(__f))
 855 {
 856     this->__set_deferred();
 857 }
 858
 859 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 860
 861 template <class _Rp, class _Fp>
 862 void
 863 __deferred_assoc_state<_Rp, _Fp>::__execute()
 864 {
 865 #ifndef _LIBCPP_NO_EXCEPTIONS
 866     try
 867     {
 868 #endif  // _LIBCPP_NO_EXCEPTIONS
 869         this->set_value(__func_());
 870 #ifndef _LIBCPP_NO_EXCEPTIONS
 871     }
 872     catch (...)
 873     {
 874         this->set_exception(current_exception());
 875     }
 876 #endif  // _LIBCPP_NO_EXCEPTIONS
 877 }
 878
 879 template <class _Fp>
 880 class __deferred_assoc_state<void, _Fp>
 881     : public __assoc_sub_state
 882 {
 883     typedef __assoc_sub_state base;
 884
 885     _Fp __func_;
 886
 887 public:
 888 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 889     explicit __deferred_assoc_state(_Fp&& __f);
 890 #endif
 891
 892     virtual void __execute();
 893 };
 894
 895 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 896
 897 template <class _Fp>
 898 inline _LIBCPP_INLINE_VISIBILITY
 899 __deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f)
 900     : __func_(_VSTD::forward<_Fp>(__f))
 901 {
 902     this->__set_deferred();
 903 }
 904
 905 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 906
 907 template <class _Fp>
 908 void
 909 __deferred_assoc_state<void, _Fp>::__execute()
 910 {
 911 #ifndef _LIBCPP_NO_EXCEPTIONS
 912     try
 913     {
 914 #endif  // _LIBCPP_NO_EXCEPTIONS
 915         __func_();
 916         this->set_value();
 917 #ifndef _LIBCPP_NO_EXCEPTIONS
 918     }
 919     catch (...)
 920     {
 921         this->set_exception(current_exception());
 922     }
 923 #endif  // _LIBCPP_NO_EXCEPTIONS
 924 }
 925
 926 template <class _Rp, class _Fp>
 927 class __async_assoc_state
 928     : public __assoc_state<_Rp>
 929 {
 930     typedef __assoc_state<_Rp> base;
 931
 932     _Fp __func_;
 933
 934     virtual void __on_zero_shared() _NOEXCEPT;
 935 public:
 936 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 937     explicit __async_assoc_state(_Fp&& __f);
 938 #endif
 939
 940     virtual void __execute();
 941 };
 942
 943 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 944
 945 template <class _Rp, class _Fp>
 946 inline _LIBCPP_INLINE_VISIBILITY
 947 __async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f)
 948     : __func_(_VSTD::forward<_Fp>(__f))
 949 {
 950 }
 951
 952 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 953
 954 template <class _Rp, class _Fp>
 955 void
 956 __async_assoc_state<_Rp, _Fp>::__execute()
 957 {
 958 #ifndef _LIBCPP_NO_EXCEPTIONS
 959     try
 960     {
 961 #endif  // _LIBCPP_NO_EXCEPTIONS
 962         this->set_value(__func_());
 963 #ifndef _LIBCPP_NO_EXCEPTIONS
 964     }
 965     catch (...)
 966     {
 967         this->set_exception(current_exception());
 968     }
 969 #endif  // _LIBCPP_NO_EXCEPTIONS
 970 }
 971
 972 template <class _Rp, class _Fp>
 973 void
 974 __async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT
 975 {
 976     this->wait();
 977     base::__on_zero_shared();
 978 }
 979
 980 template <class _Fp>
 981 class __async_assoc_state<void, _Fp>
 982     : public __assoc_sub_state
 983 {
 984     typedef __assoc_sub_state base;
 985
 986     _Fp __func_;
 987
 988     virtual void __on_zero_shared() _NOEXCEPT;
 989 public:
 990 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 991     explicit __async_assoc_state(_Fp&& __f);
 992 #endif
 993
 994     virtual void __execute();
 995 };
 996
 997 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 998
 999 template <class _Fp>
1000 inline _LIBCPP_INLINE_VISIBILITY
1001 __async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f)
1002     : __func_(_VSTD::forward<_Fp>(__f))
1003 {
1004 }
1005
1006 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1007
1008 template <class _Fp>
1009 void
1010 __async_assoc_state<void, _Fp>::__execute()
1011 {
1012 #ifndef _LIBCPP_NO_EXCEPTIONS
1013     try
1014     {
1015 #endif  // _LIBCPP_NO_EXCEPTIONS
1016         __func_();
1017         this->set_value();
1018 #ifndef _LIBCPP_NO_EXCEPTIONS
1019     }
1020     catch (...)
1021     {
1022         this->set_exception(current_exception());
1023     }
1024 #endif  // _LIBCPP_NO_EXCEPTIONS
1025 }
1026
1027 template <class _Fp>
1028 void
1029 __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT
1030 {
1031     this->wait();
1032     base::__on_zero_shared();
1033 }
1034
1035 template <class _Rp> class _LIBCPP_TYPE_VIS promise;
1036 template <class _Rp> class _LIBCPP_TYPE_VIS shared_future;
1037
1038 // future
1039
1040 template <class _Rp> class _LIBCPP_TYPE_VIS future;
1041
1042 template <class _Rp, class _Fp>
1043 future<_Rp>
1044 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1045 __make_deferred_assoc_state(_Fp&& __f);
1046 #else
1047 __make_deferred_assoc_state(_Fp __f);
1048 #endif
1049
1050 template <class _Rp, class _Fp>
1051 future<_Rp>
1052 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1053 __make_async_assoc_state(_Fp&& __f);
1054 #else
1055 __make_async_assoc_state(_Fp __f);
1056 #endif
1057
1058 template <class _Rp>
1059 class _LIBCPP_TYPE_VIS future
1060 {
1061     __assoc_state<_Rp>* __state_;
1062
1063     explicit future(__assoc_state<_Rp>* __state);
1064
1065     template <class> friend class promise;
1066     template <class> friend class shared_future;
1067
1068 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1069     template <class _R1, class _Fp>
1070         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
1071     template <class _R1, class _Fp>
1072         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
1073 #else
1074     template <class _R1, class _Fp>
1075         friend future<_R1> __make_deferred_assoc_state(_Fp __f);
1076     template <class _R1, class _Fp>
1077         friend future<_R1> __make_async_assoc_state(_Fp __f);
1078 #endif
1079
1080 public:
1081     _LIBCPP_INLINE_VISIBILITY
1082     future() _NOEXCEPT : __state_(nullptr) {}
1083 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1084     _LIBCPP_INLINE_VISIBILITY
1085     future(future&& __rhs) _NOEXCEPT
1086         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1087     future(const future&) = delete;
1088     future& operator=(const future&) = delete;
1089     _LIBCPP_INLINE_VISIBILITY
1090     future& operator=(future&& __rhs) _NOEXCEPT
1091         {
1092             future(std::move(__rhs)).swap(*this);
1093             return *this;
1094         }
1095 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1096 private:
1097     future(const future&);
1098     future& operator=(const future&);
1099 public:
1100 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1101     ~future();
1102     shared_future<_Rp> share();
1103
1104     // retrieving the value
1105     _Rp get();
1106
1107     _LIBCPP_INLINE_VISIBILITY
1108     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1109
1110     // functions to check state
1111     _LIBCPP_INLINE_VISIBILITY
1112     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
1113
1114     _LIBCPP_INLINE_VISIBILITY
1115     void wait() const {__state_->wait();}
1116     template <class _Rep, class _Period>
1117         _LIBCPP_INLINE_VISIBILITY
1118         future_status
1119         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
1120             {return __state_->wait_for(__rel_time);}
1121     template <class _Clock, class _Duration>
1122         _LIBCPP_INLINE_VISIBILITY
1123         future_status
1124         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
1125             {return __state_->wait_until(__abs_time);}
1126 };
1127
1128 template <class _Rp>
1129 future<_Rp>::future(__assoc_state<_Rp>* __state)
1130     : __state_(__state)
1131 {
1132 #ifndef _LIBCPP_NO_EXCEPTIONS
1133     if (__state_->__has_future_attached())
1134         throw future_error(make_error_code(future_errc::future_already_retrieved));
1135 #endif
1136     __state_->__add_shared();
1137     __state_->__set_future_attached();
1138 }
1139
1140 struct __release_shared_count
1141 {
1142     void operator()(__shared_count* p) {p->__release_shared();}
1143 };
1144
1145 template <class _Rp>
1146 future<_Rp>::~future()
1147 {
1148     if (__state_)
1149         __state_->__release_shared();
1150 }
1151
1152 template <class _Rp>
1153 _Rp
1154 future<_Rp>::get()
1155 {
1156     unique_ptr<__shared_count, __release_shared_count> __(__state_);
1157     __assoc_state<_Rp>* __s = __state_;
1158     __state_ = nullptr;
1159     return __s->move();
1160 }
1161
1162 template <class _Rp>
1163 class _LIBCPP_TYPE_VIS future<_Rp&>
1164 {
1165     __assoc_state<_Rp&>* __state_;
1166
1167     explicit future(__assoc_state<_Rp&>* __state);
1168
1169     template <class> friend class promise;
1170     template <class> friend class shared_future;
1171
1172 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1173     template <class _R1, class _Fp>
1174         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
1175     template <class _R1, class _Fp>
1176         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
1177 #else
1178     template <class _R1, class _Fp>
1179         friend future<_R1> __make_deferred_assoc_state(_Fp __f);
1180     template <class _R1, class _Fp>
1181         friend future<_R1> __make_async_assoc_state(_Fp __f);
1182 #endif
1183
1184 public:
1185     _LIBCPP_INLINE_VISIBILITY
1186     future() _NOEXCEPT : __state_(nullptr) {}
1187 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1188     _LIBCPP_INLINE_VISIBILITY
1189     future(future&& __rhs) _NOEXCEPT
1190         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1191     future(const future&) = delete;
1192     future& operator=(const future&) = delete;
1193     _LIBCPP_INLINE_VISIBILITY
1194     future& operator=(future&& __rhs) _NOEXCEPT
1195         {
1196             future(std::move(__rhs)).swap(*this);
1197             return *this;
1198         }
1199 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1200 private:
1201     future(const future&);
1202     future& operator=(const future&);
1203 public:
1204 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1205     ~future();
1206     shared_future<_Rp&> share();
1207
1208     // retrieving the value
1209     _Rp& get();
1210
1211     _LIBCPP_INLINE_VISIBILITY
1212     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1213
1214     // functions to check state
1215     _LIBCPP_INLINE_VISIBILITY
1216     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
1217
1218     _LIBCPP_INLINE_VISIBILITY
1219     void wait() const {__state_->wait();}
1220     template <class _Rep, class _Period>
1221         _LIBCPP_INLINE_VISIBILITY
1222         future_status
1223         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
1224             {return __state_->wait_for(__rel_time);}
1225     template <class _Clock, class _Duration>
1226         _LIBCPP_INLINE_VISIBILITY
1227         future_status
1228         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
1229             {return __state_->wait_until(__abs_time);}
1230 };
1231
1232 template <class _Rp>
1233 future<_Rp&>::future(__assoc_state<_Rp&>* __state)
1234     : __state_(__state)
1235 {
1236 #ifndef _LIBCPP_NO_EXCEPTIONS
1237     if (__state_->__has_future_attached())
1238         throw future_error(make_error_code(future_errc::future_already_retrieved));
1239 #endif
1240     __state_->__add_shared();
1241     __state_->__set_future_attached();
1242 }
1243
1244 template <class _Rp>
1245 future<_Rp&>::~future()
1246 {
1247     if (__state_)
1248         __state_->__release_shared();
1249 }
1250
1251 template <class _Rp>
1252 _Rp&
1253 future<_Rp&>::get()
1254 {
1255     unique_ptr<__shared_count, __release_shared_count> __(__state_);
1256     __assoc_state<_Rp&>* __s = __state_;
1257     __state_ = nullptr;
1258     return __s->copy();
1259 }
1260
1261 template <>
1262 class _LIBCPP_TYPE_VIS future<void>
1263 {
1264     __assoc_sub_state* __state_;
1265
1266     explicit future(__assoc_sub_state* __state);
1267
1268     template <class> friend class promise;
1269     template <class> friend class shared_future;
1270
1271 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1272     template <class _R1, class _Fp>
1273         friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);
1274     template <class _R1, class _Fp>
1275         friend future<_R1> __make_async_assoc_state(_Fp&& __f);
1276 #else
1277     template <class _R1, class _Fp>
1278         friend future<_R1> __make_deferred_assoc_state(_Fp __f);
1279     template <class _R1, class _Fp>
1280         friend future<_R1> __make_async_assoc_state(_Fp __f);
1281 #endif
1282
1283 public:
1284     _LIBCPP_INLINE_VISIBILITY
1285     future() _NOEXCEPT : __state_(nullptr) {}
1286 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1287     _LIBCPP_INLINE_VISIBILITY
1288     future(future&& __rhs) _NOEXCEPT
1289         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1290     future(const future&) = delete;
1291     future& operator=(const future&) = delete;
1292     _LIBCPP_INLINE_VISIBILITY
1293     future& operator=(future&& __rhs) _NOEXCEPT
1294         {
1295             future(std::move(__rhs)).swap(*this);
1296             return *this;
1297         }
1298 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1299 private:
1300     future(const future&);
1301     future& operator=(const future&);
1302 public:
1303 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1304     ~future();
1305     shared_future<void> share();
1306
1307     // retrieving the value
1308     void get();
1309
1310     _LIBCPP_INLINE_VISIBILITY
1311     void swap(future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1312
1313     // functions to check state
1314     _LIBCPP_INLINE_VISIBILITY
1315     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
1316
1317     _LIBCPP_INLINE_VISIBILITY
1318     void wait() const {__state_->wait();}
1319     template <class _Rep, class _Period>
1320         _LIBCPP_INLINE_VISIBILITY
1321         future_status
1322         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
1323             {return __state_->wait_for(__rel_time);}
1324     template <class _Clock, class _Duration>
1325         _LIBCPP_INLINE_VISIBILITY
1326         future_status
1327         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
1328             {return __state_->wait_until(__abs_time);}
1329 };
1330
1331 template <class _Rp>
1332 inline _LIBCPP_INLINE_VISIBILITY
1333 void
1334 swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT
1335 {
1336     __x.swap(__y);
1337 }
1338
1339 // promise<R>
1340
1341 template <class _Callable> class packaged_task;
1342
1343 template <class _Rp>
1344 class _LIBCPP_TYPE_VIS promise
1345 {
1346     __assoc_state<_Rp>* __state_;
1347
1348     _LIBCPP_INLINE_VISIBILITY
1349     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
1350
1351     template <class> friend class packaged_task;
1352 public:
1353     promise();
1354     template <class _Alloc>
1355         promise(allocator_arg_t, const _Alloc& __a);
1356 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1357     _LIBCPP_INLINE_VISIBILITY
1358     promise(promise&& __rhs) _NOEXCEPT
1359         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1360     promise(const promise& __rhs) = delete;
1361 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1362 private:
1363     promise(const promise& __rhs);
1364 public:
1365 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1366     ~promise();
1367
1368     // assignment
1369 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1370     _LIBCPP_INLINE_VISIBILITY
1371     promise& operator=(promise&& __rhs) _NOEXCEPT
1372         {
1373             promise(std::move(__rhs)).swap(*this);
1374             return *this;
1375         }
1376     promise& operator=(const promise& __rhs) = delete;
1377 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1378 private:
1379     promise& operator=(const promise& __rhs);
1380 public:
1381 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1382     _LIBCPP_INLINE_VISIBILITY
1383     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1384
1385     // retrieving the result
1386     future<_Rp> get_future();
1387
1388     // setting the result
1389     void set_value(const _Rp& __r);
1390 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1391     void set_value(_Rp&& __r);
1392 #endif
1393     void set_exception(exception_ptr __p);
1394
1395     // setting the result with deferred notification
1396     void set_value_at_thread_exit(const _Rp& __r);
1397 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1398     void set_value_at_thread_exit(_Rp&& __r);
1399 #endif
1400     void set_exception_at_thread_exit(exception_ptr __p);
1401 };
1402
1403 template <class _Rp>
1404 promise<_Rp>::promise()
1405     : __state_(new __assoc_state<_Rp>)
1406 {
1407 }
1408
1409 template <class _Rp>
1410 template <class _Alloc>
1411 promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0)
1412 {
1413     typedef typename _Alloc::template rebind<__assoc_state_alloc<_Rp, _Alloc> >::other _A2;
1414     typedef __allocator_destructor<_A2> _D2;
1415     _A2 __a(__a0);
1416     unique_ptr<__assoc_state_alloc<_Rp, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
1417     ::new(__hold.get()) __assoc_state_alloc<_Rp, _Alloc>(__a0);
1418     __state_ = __hold.release();
1419 }
1420
1421 template <class _Rp>
1422 promise<_Rp>::~promise()
1423 {
1424     if (__state_)
1425     {
1426         if (!__state_->__has_value() && __state_->use_count() > 1)
1427             __state_->set_exception(make_exception_ptr(
1428                       future_error(make_error_code(future_errc::broken_promise))
1429                                                       ));
1430         __state_->__release_shared();
1431     }
1432 }
1433
1434 template <class _Rp>
1435 future<_Rp>
1436 promise<_Rp>::get_future()
1437 {
1438 #ifndef _LIBCPP_NO_EXCEPTIONS
1439     if (__state_ == nullptr)
1440         throw future_error(make_error_code(future_errc::no_state));
1441 #endif
1442     return future<_Rp>(__state_);
1443 }
1444
1445 template <class _Rp>
1446 void
1447 promise<_Rp>::set_value(const _Rp& __r)
1448 {
1449 #ifndef _LIBCPP_NO_EXCEPTIONS
1450     if (__state_ == nullptr)
1451         throw future_error(make_error_code(future_errc::no_state));
1452 #endif
1453     __state_->set_value(__r);
1454 }
1455
1456 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1457
1458 template <class _Rp>
1459 void
1460 promise<_Rp>::set_value(_Rp&& __r)
1461 {
1462 #ifndef _LIBCPP_NO_EXCEPTIONS
1463     if (__state_ == nullptr)
1464         throw future_error(make_error_code(future_errc::no_state));
1465 #endif
1466     __state_->set_value(_VSTD::move(__r));
1467 }
1468
1469 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1470
1471 template <class _Rp>
1472 void
1473 promise<_Rp>::set_exception(exception_ptr __p)
1474 {
1475 #ifndef _LIBCPP_NO_EXCEPTIONS
1476     if (__state_ == nullptr)
1477         throw future_error(make_error_code(future_errc::no_state));
1478 #endif
1479     __state_->set_exception(__p);
1480 }
1481
1482 template <class _Rp>
1483 void
1484 promise<_Rp>::set_value_at_thread_exit(const _Rp& __r)
1485 {
1486 #ifndef _LIBCPP_NO_EXCEPTIONS
1487     if (__state_ == nullptr)
1488         throw future_error(make_error_code(future_errc::no_state));
1489 #endif
1490     __state_->set_value_at_thread_exit(__r);
1491 }
1492
1493 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1494
1495 template <class _Rp>
1496 void
1497 promise<_Rp>::set_value_at_thread_exit(_Rp&& __r)
1498 {
1499 #ifndef _LIBCPP_NO_EXCEPTIONS
1500     if (__state_ == nullptr)
1501         throw future_error(make_error_code(future_errc::no_state));
1502 #endif
1503     __state_->set_value_at_thread_exit(_VSTD::move(__r));
1504 }
1505
1506 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1507
1508 template <class _Rp>
1509 void
1510 promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p)
1511 {
1512 #ifndef _LIBCPP_NO_EXCEPTIONS
1513     if (__state_ == nullptr)
1514         throw future_error(make_error_code(future_errc::no_state));
1515 #endif
1516     __state_->set_exception_at_thread_exit(__p);
1517 }
1518
1519 // promise<R&>
1520
1521 template <class _Rp>
1522 class _LIBCPP_TYPE_VIS promise<_Rp&>
1523 {
1524     __assoc_state<_Rp&>* __state_;
1525
1526     _LIBCPP_INLINE_VISIBILITY
1527     explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}
1528
1529     template <class> friend class packaged_task;
1530
1531 public:
1532     promise();
1533     template <class _Allocator>
1534         promise(allocator_arg_t, const _Allocator& __a);
1535 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1536     _LIBCPP_INLINE_VISIBILITY
1537     promise(promise&& __rhs) _NOEXCEPT
1538         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1539     promise(const promise& __rhs) = delete;
1540 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1541 private:
1542     promise(const promise& __rhs);
1543 public:
1544 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1545     ~promise();
1546
1547     // assignment
1548 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1549     _LIBCPP_INLINE_VISIBILITY
1550     promise& operator=(promise&& __rhs) _NOEXCEPT
1551         {
1552             promise(std::move(__rhs)).swap(*this);
1553             return *this;
1554         }
1555     promise& operator=(const promise& __rhs) = delete;
1556 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1557 private:
1558     promise& operator=(const promise& __rhs);
1559 public:
1560 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1561     _LIBCPP_INLINE_VISIBILITY
1562     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1563
1564     // retrieving the result
1565     future<_Rp&> get_future();
1566
1567     // setting the result
1568     void set_value(_Rp& __r);
1569     void set_exception(exception_ptr __p);
1570
1571     // setting the result with deferred notification
1572     void set_value_at_thread_exit(_Rp&);
1573     void set_exception_at_thread_exit(exception_ptr __p);
1574 };
1575
1576 template <class _Rp>
1577 promise<_Rp&>::promise()
1578     : __state_(new __assoc_state<_Rp&>)
1579 {
1580 }
1581
1582 template <class _Rp>
1583 template <class _Alloc>
1584 promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0)
1585 {
1586     typedef typename _Alloc::template rebind<__assoc_state_alloc<_Rp&, _Alloc> >::other _A2;
1587     typedef __allocator_destructor<_A2> _D2;
1588     _A2 __a(__a0);
1589     unique_ptr<__assoc_state_alloc<_Rp&, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
1590     ::new(__hold.get()) __assoc_state_alloc<_Rp&, _Alloc>(__a0);
1591     __state_ = __hold.release();
1592 }
1593
1594 template <class _Rp>
1595 promise<_Rp&>::~promise()
1596 {
1597     if (__state_)
1598     {
1599         if (!__state_->__has_value() && __state_->use_count() > 1)
1600             __state_->set_exception(make_exception_ptr(
1601                       future_error(make_error_code(future_errc::broken_promise))
1602                                                       ));
1603         __state_->__release_shared();
1604     }
1605 }
1606
1607 template <class _Rp>
1608 future<_Rp&>
1609 promise<_Rp&>::get_future()
1610 {
1611 #ifndef _LIBCPP_NO_EXCEPTIONS
1612     if (__state_ == nullptr)
1613         throw future_error(make_error_code(future_errc::no_state));
1614 #endif
1615     return future<_Rp&>(__state_);
1616 }
1617
1618 template <class _Rp>
1619 void
1620 promise<_Rp&>::set_value(_Rp& __r)
1621 {
1622 #ifndef _LIBCPP_NO_EXCEPTIONS
1623     if (__state_ == nullptr)
1624         throw future_error(make_error_code(future_errc::no_state));
1625 #endif
1626     __state_->set_value(__r);
1627 }
1628
1629 template <class _Rp>
1630 void
1631 promise<_Rp&>::set_exception(exception_ptr __p)
1632 {
1633 #ifndef _LIBCPP_NO_EXCEPTIONS
1634     if (__state_ == nullptr)
1635         throw future_error(make_error_code(future_errc::no_state));
1636 #endif
1637     __state_->set_exception(__p);
1638 }
1639
1640 template <class _Rp>
1641 void
1642 promise<_Rp&>::set_value_at_thread_exit(_Rp& __r)
1643 {
1644 #ifndef _LIBCPP_NO_EXCEPTIONS
1645     if (__state_ == nullptr)
1646         throw future_error(make_error_code(future_errc::no_state));
1647 #endif
1648     __state_->set_value_at_thread_exit(__r);
1649 }
1650
1651 template <class _Rp>
1652 void
1653 promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p)
1654 {
1655 #ifndef _LIBCPP_NO_EXCEPTIONS
1656     if (__state_ == nullptr)
1657         throw future_error(make_error_code(future_errc::no_state));
1658 #endif
1659     __state_->set_exception_at_thread_exit(__p);
1660 }
1661
1662 // promise<void>
1663
1664 template <>
1665 class _LIBCPP_TYPE_VIS 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         promise(allocator_arg_t, const _Allocator& __a);
1678 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1679     _LIBCPP_INLINE_VISIBILITY
1680     promise(promise&& __rhs) _NOEXCEPT
1681         : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;}
1682     promise(const promise& __rhs) = delete;
1683 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1684 private:
1685     promise(const promise& __rhs);
1686 public:
1687 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1688     ~promise();
1689
1690     // assignment
1691 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
1692     _LIBCPP_INLINE_VISIBILITY
1693     promise& operator=(promise&& __rhs) _NOEXCEPT
1694         {
1695             promise(std::move(__rhs)).swap(*this);
1696             return *this;
1697         }
1698     promise& operator=(const promise& __rhs) = delete;
1699 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1700 private:
1701     promise& operator=(const promise& __rhs);
1702 public:
1703 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
1704     _LIBCPP_INLINE_VISIBILITY
1705     void swap(promise& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
1706
1707     // retrieving the result
1708     future<void> get_future();
1709
1710     // setting the result
1711     void set_value();
1712     void set_exception(exception_ptr __p);
1713
1714     // setting the result with deferred notification
1715     void set_value_at_thread_exit();
1716     void set_exception_at_thread_exit(exception_ptr __p);
1717 };
1718
1719 template <class _Alloc>
1720 promise<void>::promise(allocator_arg_t, const _Alloc& __a0)
1721 {
1722     typedef typename _Alloc::template rebind<__assoc_sub_state_alloc<_Alloc> >::other _A2;
1723     typedef __allocator_destructor<_A2> _D2;
1724     _A2 __a(__a0);
1725     unique_ptr<__assoc_sub_state_alloc<_Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1));
1726     ::new(__hold.get()) __assoc_sub_state_alloc<_Alloc>(__a0);
1727     __state_ = __hold.release();
1728 }
1729
1730 template <class _Rp>
1731 inline _LIBCPP_INLINE_VISIBILITY
1732 void
1733 swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT
1734 {
1735     __x.swap(__y);
1736 }
1737
1738 template <class _Rp, class _Alloc>
1739     struct _LIBCPP_TYPE_VIS uses_allocator<promise<_Rp>, _Alloc>
1740         : public true_type {};
1741
1742 #ifndef _LIBCPP_HAS_NO_VARIADICS
1743
1744 // packaged_task
1745
1746 template<class _Fp> class __packaged_task_base;
1747
1748 template<class _Rp, class ..._ArgTypes>
1749 class __packaged_task_base<_Rp(_ArgTypes...)>
1750 {
1751     __packaged_task_base(const __packaged_task_base&);
1752     __packaged_task_base& operator=(const __packaged_task_base&);
1753 public:
1754     _LIBCPP_INLINE_VISIBILITY
1755     __packaged_task_base() {}
1756     _LIBCPP_INLINE_VISIBILITY
1757     virtual ~__packaged_task_base() {}
1758     virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;
1759     virtual void destroy() = 0;
1760     virtual void destroy_deallocate() = 0;
1761     virtual _Rp operator()(_ArgTypes&& ...) = 0;
1762 };
1763
1764 template<class _FD, class _Alloc, class _FB> class __packaged_task_func;
1765
1766 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1767 class __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>
1768     : public  __packaged_task_base<_Rp(_ArgTypes...)>
1769 {
1770     __compressed_pair<_Fp, _Alloc> __f_;
1771 public:
1772     _LIBCPP_INLINE_VISIBILITY
1773     explicit __packaged_task_func(const _Fp& __f) : __f_(__f) {}
1774     _LIBCPP_INLINE_VISIBILITY
1775     explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f)) {}
1776     _LIBCPP_INLINE_VISIBILITY
1777     __packaged_task_func(const _Fp& __f, const _Alloc& __a)
1778         : __f_(__f, __a) {}
1779     _LIBCPP_INLINE_VISIBILITY
1780     __packaged_task_func(_Fp&& __f, const _Alloc& __a)
1781         : __f_(_VSTD::move(__f), __a) {}
1782     virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;
1783     virtual void destroy();
1784     virtual void destroy_deallocate();
1785     virtual _Rp operator()(_ArgTypes&& ... __args);
1786 };
1787
1788 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1789 void
1790 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(
1791                               __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT
1792 {
1793     ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
1794 }
1795
1796 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1797 void
1798 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy()
1799 {
1800     __f_.~__compressed_pair<_Fp, _Alloc>();
1801 }
1802
1803 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1804 void
1805 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate()
1806 {
1807     typedef typename _Alloc::template rebind<__packaged_task_func>::other _Ap;
1808     _Ap __a(__f_.second());
1809     __f_.~__compressed_pair<_Fp, _Alloc>();
1810     __a.deallocate(this, 1);
1811 }
1812
1813 template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
1814 _Rp
1815 __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
1816 {
1817     return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
1818 }
1819
1820 template <class _Callable> class __packaged_task_function;
1821
1822 template<class _Rp, class ..._ArgTypes>
1823 class __packaged_task_function<_Rp(_ArgTypes...)>
1824 {
1825     typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
1826     typename aligned_storage<3*sizeof(void*)>::type __buf_;
1827     __base* __f_;
1828
1829 public:
1830     typedef _Rp result_type;
1831
1832     // construct/copy/destroy:
1833     _LIBCPP_INLINE_VISIBILITY
1834     __packaged_task_function() _NOEXCEPT : __f_(nullptr) {}
1835     template<class _Fp>
1836       __packaged_task_function(_Fp&& __f);
1837     template<class _Fp, class _Alloc>
1838       __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f);
1839
1840     __packaged_task_function(__packaged_task_function&&) _NOEXCEPT;
1841     __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT;
1842
1843     __packaged_task_function(const __packaged_task_function&) =  delete;
1844     __packaged_task_function& operator=(const __packaged_task_function&) =  delete;
1845
1846     ~__packaged_task_function();
1847
1848     void swap(__packaged_task_function&) _NOEXCEPT;
1849
1850     _Rp operator()(_ArgTypes...) const;
1851 };
1852
1853 template<class _Rp, class ..._ArgTypes>
1854 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT
1855 {
1856     if (__f.__f_ == nullptr)
1857         __f_ = nullptr;
1858     else if (__f.__f_ == (__base*)&__f.__buf_)
1859     {
1860         __f_ = (__base*)&__buf_;
1861         __f.__f_->__move_to(__f_);
1862     }
1863     else
1864     {
1865         __f_ = __f.__f_;
1866         __f.__f_ = nullptr;
1867     }
1868 }
1869
1870 template<class _Rp, class ..._ArgTypes>
1871 template <class _Fp>
1872 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f)
1873     : __f_(nullptr)
1874 {
1875     typedef typename remove_reference<_Fp>::type _FR;
1876     typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;
1877     if (sizeof(_FF) <= sizeof(__buf_))
1878     {
1879         __f_ = (__base*)&__buf_;
1880         ::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
1881     }
1882     else
1883     {
1884         typedef allocator<_FF> _Ap;
1885         _Ap __a;
1886         typedef __allocator_destructor<_Ap> _Dp;
1887         unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1888         ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a));
1889         __f_ = __hold.release();
1890     }
1891 }
1892
1893 template<class _Rp, class ..._ArgTypes>
1894 template <class _Fp, class _Alloc>
1895 __packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(
1896                                   allocator_arg_t, const _Alloc& __a0, _Fp&& __f)
1897     : __f_(nullptr)
1898 {
1899     typedef allocator_traits<_Alloc> __alloc_traits;
1900     typedef typename remove_reference<_Fp>::type _FR;
1901     typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;
1902     if (sizeof(_FF) <= sizeof(__buf_))
1903     {
1904         __f_ = (__base*)&__buf_;
1905         ::new (__f_) _FF(_VSTD::forward<_Fp>(__f));
1906     }
1907     else
1908     {
1909         typedef typename __alloc_traits::template
1910 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
1911             rebind_alloc<_FF>
1912 #else
1913             rebind_alloc<_FF>::other
1914 #endif
1915                                                      _Ap;
1916         _Ap __a(__a0);
1917         typedef __allocator_destructor<_Ap> _Dp;
1918         unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
1919         ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), _Alloc(__a));
1920         __f_ = __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 _LIBCPP_INLINE_VISIBILITY
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_TYPE_VIS packaged_task<_Rp(_ArgTypes...)>
2004 {
2005 public:
2006     typedef _Rp result_type;
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         _LIBCPP_INLINE_VISIBILITY
2018         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
2019     template <class _Fp, class _Allocator>
2020         _LIBCPP_INLINE_VISIBILITY
2021         explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
2022              : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
2023                __p_(allocator_arg, __a) {}
2024     // ~packaged_task() = default;
2025
2026     // no copy
2027     packaged_task(const packaged_task&) = delete;
2028     packaged_task& operator=(const packaged_task&) = delete;
2029
2030     // move support
2031     _LIBCPP_INLINE_VISIBILITY
2032     packaged_task(packaged_task&& __other) _NOEXCEPT
2033         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
2034     _LIBCPP_INLINE_VISIBILITY
2035     packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
2036     {
2037         __f_ = _VSTD::move(__other.__f_);
2038         __p_ = _VSTD::move(__other.__p_);
2039         return *this;
2040     }
2041     _LIBCPP_INLINE_VISIBILITY
2042     void swap(packaged_task& __other) _NOEXCEPT
2043     {
2044         __f_.swap(__other.__f_);
2045         __p_.swap(__other.__p_);
2046     }
2047
2048     _LIBCPP_INLINE_VISIBILITY
2049     bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
2050
2051     // result retrieval
2052     _LIBCPP_INLINE_VISIBILITY
2053     future<result_type> get_future() {return __p_.get_future();}
2054
2055     // execution
2056     void operator()(_ArgTypes... __args);
2057     void make_ready_at_thread_exit(_ArgTypes... __args);
2058
2059     void reset();
2060 };
2061
2062 template<class _Rp, class ..._ArgTypes>
2063 void
2064 packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args)
2065 {
2066 #ifndef _LIBCPP_NO_EXCEPTIONS
2067     if (__p_.__state_ == nullptr)
2068         throw future_error(make_error_code(future_errc::no_state));
2069     if (__p_.__state_->__has_value())
2070         throw future_error(make_error_code(future_errc::promise_already_satisfied));
2071     try
2072     {
2073 #endif  // _LIBCPP_NO_EXCEPTIONS
2074         __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
2075 #ifndef _LIBCPP_NO_EXCEPTIONS
2076     }
2077     catch (...)
2078     {
2079         __p_.set_exception(current_exception());
2080     }
2081 #endif  // _LIBCPP_NO_EXCEPTIONS
2082 }
2083
2084 template<class _Rp, class ..._ArgTypes>
2085 void
2086 packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
2087 {
2088 #ifndef _LIBCPP_NO_EXCEPTIONS
2089     if (__p_.__state_ == nullptr)
2090         throw future_error(make_error_code(future_errc::no_state));
2091     if (__p_.__state_->__has_value())
2092         throw future_error(make_error_code(future_errc::promise_already_satisfied));
2093     try
2094     {
2095 #endif  // _LIBCPP_NO_EXCEPTIONS
2096         __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
2097 #ifndef _LIBCPP_NO_EXCEPTIONS
2098     }
2099     catch (...)
2100     {
2101         __p_.set_exception_at_thread_exit(current_exception());
2102     }
2103 #endif  // _LIBCPP_NO_EXCEPTIONS
2104 }
2105
2106 template<class _Rp, class ..._ArgTypes>
2107 void
2108 packaged_task<_Rp(_ArgTypes...)>::reset()
2109 {
2110 #ifndef _LIBCPP_NO_EXCEPTIONS
2111     if (!valid())
2112         throw future_error(make_error_code(future_errc::no_state));
2113 #endif  // _LIBCPP_NO_EXCEPTIONS
2114     __p_ = promise<result_type>();
2115 }
2116
2117 template<class ..._ArgTypes>
2118 class _LIBCPP_TYPE_VIS packaged_task<void(_ArgTypes...)>
2119 {
2120 public:
2121     typedef void result_type;
2122
2123 private:
2124     __packaged_task_function<result_type(_ArgTypes...)> __f_;
2125     promise<result_type>                                __p_;
2126
2127 public:
2128     // construction and destruction
2129     _LIBCPP_INLINE_VISIBILITY
2130     packaged_task() _NOEXCEPT : __p_(nullptr) {}
2131     template <class _Fp>
2132         _LIBCPP_INLINE_VISIBILITY
2133         explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {}
2134     template <class _Fp, class _Allocator>
2135         _LIBCPP_INLINE_VISIBILITY
2136         explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)
2137              : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)),
2138                __p_(allocator_arg, __a) {}
2139     // ~packaged_task() = default;
2140
2141     // no copy
2142     packaged_task(const packaged_task&) = delete;
2143     packaged_task& operator=(const packaged_task&) = delete;
2144
2145     // move support
2146     _LIBCPP_INLINE_VISIBILITY
2147     packaged_task(packaged_task&& __other) _NOEXCEPT
2148         : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
2149     _LIBCPP_INLINE_VISIBILITY
2150     packaged_task& operator=(packaged_task&& __other) _NOEXCEPT
2151     {
2152         __f_ = _VSTD::move(__other.__f_);
2153         __p_ = _VSTD::move(__other.__p_);
2154         return *this;
2155     }
2156     _LIBCPP_INLINE_VISIBILITY
2157     void swap(packaged_task& __other) _NOEXCEPT
2158     {
2159         __f_.swap(__other.__f_);
2160         __p_.swap(__other.__p_);
2161     }
2162
2163     _LIBCPP_INLINE_VISIBILITY
2164     bool valid() const _NOEXCEPT {return __p_.__state_ != nullptr;}
2165
2166     // result retrieval
2167     _LIBCPP_INLINE_VISIBILITY
2168     future<result_type> get_future() {return __p_.get_future();}
2169
2170     // execution
2171     void operator()(_ArgTypes... __args);
2172     void make_ready_at_thread_exit(_ArgTypes... __args);
2173
2174     void reset();
2175 };
2176
2177 template<class ..._ArgTypes>
2178 void
2179 packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
2180 {
2181 #ifndef _LIBCPP_NO_EXCEPTIONS
2182     if (__p_.__state_ == nullptr)
2183         throw future_error(make_error_code(future_errc::no_state));
2184     if (__p_.__state_->__has_value())
2185         throw future_error(make_error_code(future_errc::promise_already_satisfied));
2186     try
2187     {
2188 #endif  // _LIBCPP_NO_EXCEPTIONS
2189         __f_(_VSTD::forward<_ArgTypes>(__args)...);
2190         __p_.set_value();
2191 #ifndef _LIBCPP_NO_EXCEPTIONS
2192     }
2193     catch (...)
2194     {
2195         __p_.set_exception(current_exception());
2196     }
2197 #endif  // _LIBCPP_NO_EXCEPTIONS
2198 }
2199
2200 template<class ..._ArgTypes>
2201 void
2202 packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
2203 {
2204 #ifndef _LIBCPP_NO_EXCEPTIONS
2205     if (__p_.__state_ == nullptr)
2206         throw future_error(make_error_code(future_errc::no_state));
2207     if (__p_.__state_->__has_value())
2208         throw future_error(make_error_code(future_errc::promise_already_satisfied));
2209     try
2210     {
2211 #endif  // _LIBCPP_NO_EXCEPTIONS
2212         __f_(_VSTD::forward<_ArgTypes>(__args)...);
2213         __p_.set_value_at_thread_exit();
2214 #ifndef _LIBCPP_NO_EXCEPTIONS
2215     }
2216     catch (...)
2217     {
2218         __p_.set_exception_at_thread_exit(current_exception());
2219     }
2220 #endif  // _LIBCPP_NO_EXCEPTIONS
2221 }
2222
2223 template<class ..._ArgTypes>
2224 void
2225 packaged_task<void(_ArgTypes...)>::reset()
2226 {
2227 #ifndef _LIBCPP_NO_EXCEPTIONS
2228     if (!valid())
2229         throw future_error(make_error_code(future_errc::no_state));
2230 #endif  // _LIBCPP_NO_EXCEPTIONS
2231     __p_ = promise<result_type>();
2232 }
2233
2234 template <class _Callable>
2235 inline _LIBCPP_INLINE_VISIBILITY
2236 void
2237 swap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) _NOEXCEPT
2238 {
2239     __x.swap(__y);
2240 }
2241
2242 template <class _Callable, class _Alloc>
2243 struct _LIBCPP_TYPE_VIS uses_allocator<packaged_task<_Callable>, _Alloc>
2244     : public true_type {};
2245
2246 template <class _Rp, class _Fp>
2247 future<_Rp>
2248 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2249 __make_deferred_assoc_state(_Fp&& __f)
2250 #else
2251 __make_deferred_assoc_state(_Fp __f)
2252 #endif
2253 {
2254     unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count>
2255         __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
2256     return future<_Rp>(__h.get());
2257 }
2258
2259 template <class _Rp, class _Fp>
2260 future<_Rp>
2261 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2262 __make_async_assoc_state(_Fp&& __f)
2263 #else
2264 __make_async_assoc_state(_Fp __f)
2265 #endif
2266 {
2267     unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count>
2268         __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f)));
2269     _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
2270     return future<_Rp>(__h.get());
2271 }
2272
2273 template <class _Fp, class... _Args>
2274 class __async_func
2275 {
2276     tuple<_Fp, _Args...> __f_;
2277
2278 public:
2279     typedef typename __invoke_of<_Fp, _Args...>::type _Rp;
2280
2281     _LIBCPP_INLINE_VISIBILITY
2282     explicit __async_func(_Fp&& __f, _Args&&... __args)
2283         : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}
2284
2285     _LIBCPP_INLINE_VISIBILITY
2286     __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {}
2287
2288     _Rp operator()()
2289     {
2290         typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index;
2291         return __execute(_Index());
2292     }
2293 private:
2294     template <size_t ..._Indices>
2295     _Rp
2296     __execute(__tuple_indices<_Indices...>)
2297     {
2298         return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
2299     }
2300 };
2301
2302 template <class _Fp, class... _Args>
2303 future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
2304 async(launch __policy, _Fp&& __f, _Args&&... __args)
2305 {
2306     typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF;
2307     typedef typename _BF::_Rp _Rp;
2308     future<_Rp> __r;
2309     if (int(__policy) & int(launch::async))
2310         __r = _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
2311                                                      __decay_copy(_VSTD::forward<_Args>(__args))...));
2312     else if (int(__policy) & int(launch::deferred))
2313         __r = _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)),
2314                                                         __decay_copy(_VSTD::forward<_Args>(__args))...));
2315     return __r;
2316 }
2317
2318 template <class _Fp, class... _Args>
2319 inline _LIBCPP_INLINE_VISIBILITY
2320 future<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type>
2321 async(_Fp&& __f, _Args&&... __args)
2322 {
2323     return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f),
2324                                     _VSTD::forward<_Args>(__args)...);
2325 }
2326
2327 #endif  // _LIBCPP_HAS_NO_VARIADICS
2328
2329 // shared_future
2330
2331 template <class _Rp>
2332 class _LIBCPP_TYPE_VIS shared_future
2333 {
2334     __assoc_state<_Rp>* __state_;
2335
2336 public:
2337     _LIBCPP_INLINE_VISIBILITY
2338     shared_future() _NOEXCEPT : __state_(nullptr) {}
2339     _LIBCPP_INLINE_VISIBILITY
2340     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
2341         {if (__state_) __state_->__add_shared();}
2342 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2343     _LIBCPP_INLINE_VISIBILITY
2344     shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_)
2345         {__f.__state_ = nullptr;}
2346     _LIBCPP_INLINE_VISIBILITY
2347     shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
2348         {__rhs.__state_ = nullptr;}
2349 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
2350     ~shared_future();
2351     shared_future& operator=(const shared_future& __rhs);
2352 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2353     _LIBCPP_INLINE_VISIBILITY
2354     shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
2355         {
2356             shared_future(std::move(__rhs)).swap(*this);
2357             return *this;
2358         }
2359 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
2360
2361     // retrieving the value
2362     _LIBCPP_INLINE_VISIBILITY
2363     const _Rp& get() const {return __state_->copy();}
2364
2365     _LIBCPP_INLINE_VISIBILITY
2366     void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
2367
2368     // functions to check state
2369     _LIBCPP_INLINE_VISIBILITY
2370     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
2371
2372     _LIBCPP_INLINE_VISIBILITY
2373     void wait() const {__state_->wait();}
2374     template <class _Rep, class _Period>
2375         _LIBCPP_INLINE_VISIBILITY
2376         future_status
2377         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
2378             {return __state_->wait_for(__rel_time);}
2379     template <class _Clock, class _Duration>
2380         _LIBCPP_INLINE_VISIBILITY
2381         future_status
2382         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
2383             {return __state_->wait_until(__abs_time);}
2384 };
2385
2386 template <class _Rp>
2387 shared_future<_Rp>::~shared_future()
2388 {
2389     if (__state_)
2390         __state_->__release_shared();
2391 }
2392
2393 template <class _Rp>
2394 shared_future<_Rp>&
2395 shared_future<_Rp>::operator=(const shared_future& __rhs)
2396 {
2397     if (__rhs.__state_)
2398         __rhs.__state_->__add_shared();
2399     if (__state_)
2400         __state_->__release_shared();
2401     __state_ = __rhs.__state_;
2402     return *this;
2403 }
2404
2405 template <class _Rp>
2406 class _LIBCPP_TYPE_VIS shared_future<_Rp&>
2407 {
2408     __assoc_state<_Rp&>* __state_;
2409
2410 public:
2411     _LIBCPP_INLINE_VISIBILITY
2412     shared_future() _NOEXCEPT : __state_(nullptr) {}
2413     _LIBCPP_INLINE_VISIBILITY
2414     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
2415         {if (__state_) __state_->__add_shared();}
2416 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2417     _LIBCPP_INLINE_VISIBILITY
2418     shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_)
2419         {__f.__state_ = nullptr;}
2420     _LIBCPP_INLINE_VISIBILITY
2421     shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
2422         {__rhs.__state_ = nullptr;}
2423 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
2424     ~shared_future();
2425     shared_future& operator=(const shared_future& __rhs);
2426 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2427     _LIBCPP_INLINE_VISIBILITY
2428     shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
2429         {
2430             shared_future(std::move(__rhs)).swap(*this);
2431             return *this;
2432         }
2433 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
2434
2435     // retrieving the value
2436     _LIBCPP_INLINE_VISIBILITY
2437     _Rp& get() const {return __state_->copy();}
2438
2439     _LIBCPP_INLINE_VISIBILITY
2440     void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
2441
2442     // functions to check state
2443     _LIBCPP_INLINE_VISIBILITY
2444     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
2445
2446     _LIBCPP_INLINE_VISIBILITY
2447     void wait() const {__state_->wait();}
2448     template <class _Rep, class _Period>
2449         _LIBCPP_INLINE_VISIBILITY
2450         future_status
2451         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
2452             {return __state_->wait_for(__rel_time);}
2453     template <class _Clock, class _Duration>
2454         _LIBCPP_INLINE_VISIBILITY
2455         future_status
2456         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
2457             {return __state_->wait_until(__abs_time);}
2458 };
2459
2460 template <class _Rp>
2461 shared_future<_Rp&>::~shared_future()
2462 {
2463     if (__state_)
2464         __state_->__release_shared();
2465 }
2466
2467 template <class _Rp>
2468 shared_future<_Rp&>&
2469 shared_future<_Rp&>::operator=(const shared_future& __rhs)
2470 {
2471     if (__rhs.__state_)
2472         __rhs.__state_->__add_shared();
2473     if (__state_)
2474         __state_->__release_shared();
2475     __state_ = __rhs.__state_;
2476     return *this;
2477 }
2478
2479 template <>
2480 class _LIBCPP_TYPE_VIS shared_future<void>
2481 {
2482     __assoc_sub_state* __state_;
2483
2484 public:
2485     _LIBCPP_INLINE_VISIBILITY
2486     shared_future() _NOEXCEPT : __state_(nullptr) {}
2487     _LIBCPP_INLINE_VISIBILITY
2488     shared_future(const shared_future& __rhs) : __state_(__rhs.__state_)
2489         {if (__state_) __state_->__add_shared();}
2490 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2491     _LIBCPP_INLINE_VISIBILITY
2492     shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_)
2493         {__f.__state_ = nullptr;}
2494     _LIBCPP_INLINE_VISIBILITY
2495     shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_)
2496         {__rhs.__state_ = nullptr;}
2497 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
2498     ~shared_future();
2499     shared_future& operator=(const shared_future& __rhs);
2500 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2501     _LIBCPP_INLINE_VISIBILITY
2502     shared_future& operator=(shared_future&& __rhs) _NOEXCEPT
2503         {
2504             shared_future(std::move(__rhs)).swap(*this);
2505             return *this;
2506         }
2507 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
2508
2509     // retrieving the value
2510     _LIBCPP_INLINE_VISIBILITY
2511     void get() const {__state_->copy();}
2512
2513     _LIBCPP_INLINE_VISIBILITY
2514     void swap(shared_future& __rhs) _NOEXCEPT {_VSTD::swap(__state_, __rhs.__state_);}
2515
2516     // functions to check state
2517     _LIBCPP_INLINE_VISIBILITY
2518     bool valid() const _NOEXCEPT {return __state_ != nullptr;}
2519
2520     _LIBCPP_INLINE_VISIBILITY
2521     void wait() const {__state_->wait();}
2522     template <class _Rep, class _Period>
2523         _LIBCPP_INLINE_VISIBILITY
2524         future_status
2525         wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
2526             {return __state_->wait_for(__rel_time);}
2527     template <class _Clock, class _Duration>
2528         _LIBCPP_INLINE_VISIBILITY
2529         future_status
2530         wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
2531             {return __state_->wait_until(__abs_time);}
2532 };
2533
2534 template <class _Rp>
2535 inline _LIBCPP_INLINE_VISIBILITY
2536 void
2537 swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT
2538 {
2539     __x.swap(__y);
2540 }
2541
2542 template <class _Rp>
2543 inline _LIBCPP_INLINE_VISIBILITY
2544 shared_future<_Rp>
2545 future<_Rp>::share()
2546 {
2547     return shared_future<_Rp>(_VSTD::move(*this));
2548 }
2549
2550 template <class _Rp>
2551 inline _LIBCPP_INLINE_VISIBILITY
2552 shared_future<_Rp&>
2553 future<_Rp&>::share()
2554 {
2555     return shared_future<_Rp&>(_VSTD::move(*this));
2556 }
2557
2558 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
2559
2560 inline _LIBCPP_INLINE_VISIBILITY
2561 shared_future<void>
2562 future<void>::share()
2563 {
2564     return shared_future<void>(_VSTD::move(*this));
2565 }
2566
2567 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
2568
2569 _LIBCPP_END_NAMESPACE_STD
2570
2571 #endif  // _LIBCPP_FUTURE