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