contrib/libc++/include/future

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