1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5// See https://llvm.org/LICENSE.txt for license information. 6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef _LIBCPP_FUTURE 11#define _LIBCPP_FUTURE 12 13/* 14 future synopsis 15 16namespace std 17{ 18 19enum class future_errc 20{ 21 future_already_retrieved = 1, 22 promise_already_satisfied, 23 no_state, 24 broken_promise 25}; 26 27enum class launch 28{ 29 async = 1, 30 deferred = 2, 31 any = async | deferred 32}; 33 34enum class future_status 35{ 36 ready, 37 timeout, 38 deferred 39}; 40 41template <> struct is_error_code_enum<future_errc> : public true_type { }; 42error_code make_error_code(future_errc e) noexcept; 43error_condition make_error_condition(future_errc e) noexcept; 44 45const error_category& future_category() noexcept; 46 47class future_error : public logic_error { 48public: 49 explicit future_error(future_errc e); // since C++17 50 51 const error_code& code() const noexcept; 52 const char* what() const noexcept; 53 54private: 55 error_code ec_; // exposition only 56}; 57 58template <class R> 59class promise 60{ 61public: 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 88template <class R> 89class promise<R&> 90{ 91public: 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 116template <> 117class promise<void> 118{ 119public: 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 144template <class R> void swap(promise<R>& x, promise<R>& y) noexcept; 145 146template <class R, class Alloc> 147 struct uses_allocator<promise<R>, Alloc> : public true_type {}; 148 149template <class R> 150class future 151{ 152public: 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 176template <class R> 177class future<R&> 178{ 179public: 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 203template <> 204class future<void> 205{ 206public: 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 230template <class R> 231class shared_future 232{ 233public: 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 257template <class R> 258class shared_future<R&> 259{ 260public: 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 284template <> 285class shared_future<void> 286{ 287public: 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 311template <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 315template <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 319template <class> class packaged_task; // undefined 320 321template <class R, class... ArgTypes> 322class packaged_task<R(ArgTypes...)> 323{ 324public: 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 356template <class R> 357 void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&) noexcept; 358 359template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>; 360 361} // std 362 363*/ 364 365#include <__config> 366 367#if !defined(_LIBCPP_HAS_NO_THREADS) 368 369# include <__assert> 370# include <__chrono/duration.h> 371# include <__chrono/time_point.h> 372# include <__exception/exception_ptr.h> 373# include <__memory/addressof.h> 374# include <__memory/allocator.h> 375# include <__memory/allocator_arg_t.h> 376# include <__memory/allocator_destructor.h> 377# include <__memory/allocator_traits.h> 378# include <__memory/compressed_pair.h> 379# include <__memory/pointer_traits.h> 380# include <__memory/shared_ptr.h> 381# include <__memory/unique_ptr.h> 382# include <__memory/uses_allocator.h> 383# include <__system_error/error_category.h> 384# include <__system_error/error_code.h> 385# include <__system_error/error_condition.h> 386# include <__type_traits/aligned_storage.h> 387# include <__type_traits/strip_signature.h> 388# include <__utility/auto_cast.h> 389# include <__utility/forward.h> 390# include <__utility/move.h> 391# include <mutex> 392# include <new> 393# include <stdexcept> 394# include <thread> 395# include <version> 396 397# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 398# pragma GCC system_header 399# endif 400 401_LIBCPP_PUSH_MACROS 402# include <__undef_macros> 403 404_LIBCPP_BEGIN_NAMESPACE_STD 405 406// enum class future_errc 407_LIBCPP_DECLARE_STRONG_ENUM(future_errc){ 408 future_already_retrieved = 1, promise_already_satisfied, no_state, broken_promise}; 409_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc) 410 411template <> 412struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc> : public true_type {}; 413 414# ifdef _LIBCPP_CXX03_LANG 415template <> 416struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type {}; 417# endif 418 419// enum class launch 420_LIBCPP_DECLARE_STRONG_ENUM(launch){async = 1, deferred = 2, any = async | deferred}; 421_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch) 422 423# ifndef _LIBCPP_CXX03_LANG 424 425typedef underlying_type<launch>::type __launch_underlying_type; 426 427inline _LIBCPP_HIDE_FROM_ABI constexpr launch operator&(launch __x, launch __y) { 428 return static_cast<launch>(static_cast<__launch_underlying_type>(__x) & static_cast<__launch_underlying_type>(__y)); 429} 430 431inline _LIBCPP_HIDE_FROM_ABI constexpr launch operator|(launch __x, launch __y) { 432 return static_cast<launch>(static_cast<__launch_underlying_type>(__x) | static_cast<__launch_underlying_type>(__y)); 433} 434 435inline _LIBCPP_HIDE_FROM_ABI constexpr launch operator^(launch __x, launch __y) { 436 return static_cast<launch>(static_cast<__launch_underlying_type>(__x) ^ static_cast<__launch_underlying_type>(__y)); 437} 438 439inline _LIBCPP_HIDE_FROM_ABI constexpr launch operator~(launch __x) { 440 return static_cast<launch>(~static_cast<__launch_underlying_type>(__x) & 3); 441} 442 443inline _LIBCPP_HIDE_FROM_ABI launch& operator&=(launch& __x, launch __y) { 444 __x = __x & __y; 445 return __x; 446} 447 448inline _LIBCPP_HIDE_FROM_ABI launch& operator|=(launch& __x, launch __y) { 449 __x = __x | __y; 450 return __x; 451} 452 453inline _LIBCPP_HIDE_FROM_ABI launch& operator^=(launch& __x, launch __y) { 454 __x = __x ^ __y; 455 return __x; 456} 457 458# endif // !_LIBCPP_CXX03_LANG 459 460// enum class future_status 461_LIBCPP_DECLARE_STRONG_ENUM(future_status){ready, timeout, deferred}; 462_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status) 463 464_LIBCPP_EXPORTED_FROM_ABI const error_category& future_category() _NOEXCEPT; 465 466inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(future_errc __e) _NOEXCEPT { 467 return error_code(static_cast<int>(__e), future_category()); 468} 469 470inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(future_errc __e) _NOEXCEPT { 471 return error_condition(static_cast<int>(__e), future_category()); 472} 473 474_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_future_error(future_errc __ev); 475 476class _LIBCPP_EXPORTED_FROM_ABI future_error : public logic_error { 477 error_code __ec_; 478 479 future_error(error_code); 480 friend void __throw_future_error(future_errc); 481 template <class> 482 friend class promise; 483 484public: 485# if _LIBCPP_STD_VER >= 17 486 _LIBCPP_HIDE_FROM_ABI explicit future_error(future_errc __ec) : future_error(std::make_error_code(__ec)) {} 487# endif 488 489 _LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; } 490 491 _LIBCPP_HIDE_FROM_ABI future_error(const future_error&) _NOEXCEPT = default; 492 ~future_error() _NOEXCEPT override; 493}; 494 495// Declared above std::future_error 496void __throw_future_error(future_errc __ev) { 497# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 498 throw future_error(make_error_code(__ev)); 499# else 500 (void)__ev; 501 _LIBCPP_VERBOSE_ABORT("future_error was thrown in -fno-exceptions mode"); 502# endif 503} 504 505class _LIBCPP_EXPORTED_FROM_ABI __assoc_sub_state : public __shared_count { 506protected: 507 exception_ptr __exception_; 508 mutable mutex __mut_; 509 mutable condition_variable __cv_; 510 unsigned __state_; 511 512 void __on_zero_shared() _NOEXCEPT override; 513 void __sub_wait(unique_lock<mutex>& __lk); 514 515public: 516 enum { __constructed = 1, __future_attached = 2, ready = 4, deferred = 8 }; 517 518 _LIBCPP_HIDE_FROM_ABI __assoc_sub_state() : __state_(0) {} 519 520 _LIBCPP_HIDE_FROM_ABI bool __has_value() const { return (__state_ & __constructed) || (__exception_ != nullptr); } 521 522 _LIBCPP_HIDE_FROM_ABI void __attach_future() { 523 lock_guard<mutex> __lk(__mut_); 524 bool __has_future_attached = (__state_ & __future_attached) != 0; 525 if (__has_future_attached) 526 __throw_future_error(future_errc::future_already_retrieved); 527 this->__add_shared(); 528 __state_ |= __future_attached; 529 } 530 531 _LIBCPP_HIDE_FROM_ABI void __set_deferred() { __state_ |= deferred; } 532 533 void __make_ready(); 534 _LIBCPP_HIDE_FROM_ABI bool __is_ready() const { return (__state_ & ready) != 0; } 535 536 void set_value(); 537 void set_value_at_thread_exit(); 538 539 void set_exception(exception_ptr __p); 540 void set_exception_at_thread_exit(exception_ptr __p); 541 542 void copy(); 543 544 void wait(); 545 template <class _Rep, class _Period> 546 future_status _LIBCPP_HIDE_FROM_ABI wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const; 547 template <class _Clock, class _Duration> 548 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS future_status 549 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const; 550 551 virtual void __execute(); 552}; 553 554template <class _Clock, class _Duration> 555future_status __assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const { 556 unique_lock<mutex> __lk(__mut_); 557 if (__state_ & deferred) 558 return future_status::deferred; 559 while (!(__state_ & ready) && _Clock::now() < __abs_time) 560 __cv_.wait_until(__lk, __abs_time); 561 if (__state_ & ready) 562 return future_status::ready; 563 return future_status::timeout; 564} 565 566template <class _Rep, class _Period> 567inline future_status __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const { 568 return wait_until(chrono::steady_clock::now() + __rel_time); 569} 570 571template <class _Rp> 572class _LIBCPP_HIDDEN __assoc_state : public __assoc_sub_state { 573 typedef __assoc_sub_state base; 574 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 575 typedef typename aligned_storage<sizeof(_Rp), _LIBCPP_ALIGNOF(_Rp)>::type _Up; 576 _LIBCPP_SUPPRESS_DEPRECATED_POP 577 578protected: 579 _Up __value_; 580 581 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override; 582 583public: 584 template <class _Arg> 585 _LIBCPP_HIDE_FROM_ABI void set_value(_Arg&& __arg); 586 587 template <class _Arg> 588 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Arg&& __arg); 589 590 _LIBCPP_HIDE_FROM_ABI _Rp move(); 591 _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<_Rp> copy(); 592}; 593 594template <class _Rp> 595void __assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT { 596 if (this->__state_ & base::__constructed) 597 reinterpret_cast<_Rp*>(&__value_)->~_Rp(); 598 delete this; 599} 600 601template <class _Rp> 602template <class _Arg> 603void __assoc_state<_Rp>::set_value(_Arg&& __arg) { 604 unique_lock<mutex> __lk(this->__mut_); 605 if (this->__has_value()) 606 __throw_future_error(future_errc::promise_already_satisfied); 607 ::new ((void*)&__value_) _Rp(std::forward<_Arg>(__arg)); 608 this->__state_ |= base::__constructed | base::ready; 609 __cv_.notify_all(); 610} 611 612template <class _Rp> 613template <class _Arg> 614void __assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg) { 615 unique_lock<mutex> __lk(this->__mut_); 616 if (this->__has_value()) 617 __throw_future_error(future_errc::promise_already_satisfied); 618 ::new ((void*)&__value_) _Rp(std::forward<_Arg>(__arg)); 619 this->__state_ |= base::__constructed; 620 __thread_local_data()->__make_ready_at_thread_exit(this); 621} 622 623template <class _Rp> 624_Rp __assoc_state<_Rp>::move() { 625 unique_lock<mutex> __lk(this->__mut_); 626 this->__sub_wait(__lk); 627 if (this->__exception_ != nullptr) 628 std::rethrow_exception(this->__exception_); 629 return std::move(*reinterpret_cast<_Rp*>(&__value_)); 630} 631 632template <class _Rp> 633__add_lvalue_reference_t<_Rp> __assoc_state<_Rp>::copy() { 634 unique_lock<mutex> __lk(this->__mut_); 635 this->__sub_wait(__lk); 636 if (this->__exception_ != nullptr) 637 std::rethrow_exception(this->__exception_); 638 return *reinterpret_cast<_Rp*>(&__value_); 639} 640 641template <class _Rp> 642class __assoc_state<_Rp&> : public __assoc_sub_state { 643 typedef __assoc_sub_state base; 644 typedef _Rp* _Up; 645 646protected: 647 _Up __value_; 648 649 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override; 650 651public: 652 _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __arg); 653 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp& __arg); 654 655 _LIBCPP_HIDE_FROM_ABI _Rp& copy(); 656}; 657 658template <class _Rp> 659void __assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT { 660 delete this; 661} 662 663template <class _Rp> 664void __assoc_state<_Rp&>::set_value(_Rp& __arg) { 665 unique_lock<mutex> __lk(this->__mut_); 666 if (this->__has_value()) 667 __throw_future_error(future_errc::promise_already_satisfied); 668 __value_ = std::addressof(__arg); 669 this->__state_ |= base::__constructed | base::ready; 670 __cv_.notify_all(); 671} 672 673template <class _Rp> 674void __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg) { 675 unique_lock<mutex> __lk(this->__mut_); 676 if (this->__has_value()) 677 __throw_future_error(future_errc::promise_already_satisfied); 678 __value_ = std::addressof(__arg); 679 this->__state_ |= base::__constructed; 680 __thread_local_data()->__make_ready_at_thread_exit(this); 681} 682 683template <class _Rp> 684_Rp& __assoc_state<_Rp&>::copy() { 685 unique_lock<mutex> __lk(this->__mut_); 686 this->__sub_wait(__lk); 687 if (this->__exception_ != nullptr) 688 std::rethrow_exception(this->__exception_); 689 return *__value_; 690} 691 692template <class _Rp, class _Alloc> 693class __assoc_state_alloc : public __assoc_state<_Rp> { 694 typedef __assoc_state<_Rp> base; 695 _Alloc __alloc_; 696 697 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT; 698 699public: 700 _LIBCPP_HIDE_FROM_ABI explicit __assoc_state_alloc(const _Alloc& __a) : __alloc_(__a) {} 701}; 702 703template <class _Rp, class _Alloc> 704void __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT { 705 if (this->__state_ & base::__constructed) 706 reinterpret_cast<_Rp*>(std::addressof(this->__value_))->~_Rp(); 707 typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al; 708 typedef allocator_traits<_Al> _ATraits; 709 typedef pointer_traits<typename _ATraits::pointer> _PTraits; 710 _Al __a(__alloc_); 711 this->~__assoc_state_alloc(); 712 __a.deallocate(_PTraits::pointer_to(*this), 1); 713} 714 715template <class _Rp, class _Alloc> 716class __assoc_state_alloc<_Rp&, _Alloc> : public __assoc_state<_Rp&> { 717 typedef __assoc_state<_Rp&> base; 718 _Alloc __alloc_; 719 720 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT; 721 722public: 723 _LIBCPP_HIDE_FROM_ABI explicit __assoc_state_alloc(const _Alloc& __a) : __alloc_(__a) {} 724}; 725 726template <class _Rp, class _Alloc> 727void __assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT { 728 typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al; 729 typedef allocator_traits<_Al> _ATraits; 730 typedef pointer_traits<typename _ATraits::pointer> _PTraits; 731 _Al __a(__alloc_); 732 this->~__assoc_state_alloc(); 733 __a.deallocate(_PTraits::pointer_to(*this), 1); 734} 735 736template <class _Alloc> 737class __assoc_sub_state_alloc : public __assoc_sub_state { 738 typedef __assoc_sub_state base; 739 _Alloc __alloc_; 740 741 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override; 742 743public: 744 _LIBCPP_HIDE_FROM_ABI explicit __assoc_sub_state_alloc(const _Alloc& __a) : __alloc_(__a) {} 745}; 746 747template <class _Alloc> 748void __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT { 749 typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al; 750 typedef allocator_traits<_Al> _ATraits; 751 typedef pointer_traits<typename _ATraits::pointer> _PTraits; 752 _Al __a(__alloc_); 753 this->~__assoc_sub_state_alloc(); 754 __a.deallocate(_PTraits::pointer_to(*this), 1); 755} 756 757template <class _Rp, class _Fp> 758class __deferred_assoc_state : public __assoc_state<_Rp> { 759 typedef __assoc_state<_Rp> base; 760 761 _Fp __func_; 762 763public: 764 _LIBCPP_HIDE_FROM_ABI explicit __deferred_assoc_state(_Fp&& __f); 765 766 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute(); 767}; 768 769template <class _Rp, class _Fp> 770inline __deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) { 771 this->__set_deferred(); 772} 773 774template <class _Rp, class _Fp> 775void __deferred_assoc_state<_Rp, _Fp>::__execute() { 776# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 777 try { 778# endif // _LIBCPP_HAS_NO_EXCEPTIONS 779 this->set_value(__func_()); 780# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 781 } catch (...) { 782 this->set_exception(current_exception()); 783 } 784# endif // _LIBCPP_HAS_NO_EXCEPTIONS 785} 786 787template <class _Fp> 788class __deferred_assoc_state<void, _Fp> : public __assoc_sub_state { 789 typedef __assoc_sub_state base; 790 791 _Fp __func_; 792 793public: 794 _LIBCPP_HIDE_FROM_ABI explicit __deferred_assoc_state(_Fp&& __f); 795 796 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override; 797}; 798 799template <class _Fp> 800inline __deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) { 801 this->__set_deferred(); 802} 803 804template <class _Fp> 805void __deferred_assoc_state<void, _Fp>::__execute() { 806# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 807 try { 808# endif // _LIBCPP_HAS_NO_EXCEPTIONS 809 __func_(); 810 this->set_value(); 811# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 812 } catch (...) { 813 this->set_exception(current_exception()); 814 } 815# endif // _LIBCPP_HAS_NO_EXCEPTIONS 816} 817 818template <class _Rp, class _Fp> 819class __async_assoc_state : public __assoc_state<_Rp> { 820 typedef __assoc_state<_Rp> base; 821 822 _Fp __func_; 823 824 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT; 825 826public: 827 _LIBCPP_HIDE_FROM_ABI explicit __async_assoc_state(_Fp&& __f); 828 829 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute(); 830}; 831 832template <class _Rp, class _Fp> 833inline __async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {} 834 835template <class _Rp, class _Fp> 836void __async_assoc_state<_Rp, _Fp>::__execute() { 837# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 838 try { 839# endif // _LIBCPP_HAS_NO_EXCEPTIONS 840 this->set_value(__func_()); 841# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 842 } catch (...) { 843 this->set_exception(current_exception()); 844 } 845# endif // _LIBCPP_HAS_NO_EXCEPTIONS 846} 847 848template <class _Rp, class _Fp> 849void __async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT { 850 this->wait(); 851 base::__on_zero_shared(); 852} 853 854template <class _Fp> 855class __async_assoc_state<void, _Fp> : public __assoc_sub_state { 856 typedef __assoc_sub_state base; 857 858 _Fp __func_; 859 860 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override; 861 862public: 863 _LIBCPP_HIDE_FROM_ABI explicit __async_assoc_state(_Fp&& __f); 864 865 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override; 866}; 867 868template <class _Fp> 869inline __async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {} 870 871template <class _Fp> 872void __async_assoc_state<void, _Fp>::__execute() { 873# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 874 try { 875# endif // _LIBCPP_HAS_NO_EXCEPTIONS 876 __func_(); 877 this->set_value(); 878# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 879 } catch (...) { 880 this->set_exception(current_exception()); 881 } 882# endif // _LIBCPP_HAS_NO_EXCEPTIONS 883} 884 885template <class _Fp> 886void __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT { 887 this->wait(); 888 base::__on_zero_shared(); 889} 890 891template <class _Rp> 892class _LIBCPP_TEMPLATE_VIS promise; 893template <class _Rp> 894class _LIBCPP_TEMPLATE_VIS shared_future; 895 896// future 897 898template <class _Rp> 899class _LIBCPP_TEMPLATE_VIS future; 900 901template <class _Rp, class _Fp> 902_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_deferred_assoc_state(_Fp&& __f); 903 904template <class _Rp, class _Fp> 905_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_async_assoc_state(_Fp&& __f); 906 907template <class _Rp> 908class _LIBCPP_TEMPLATE_VIS future { 909 __assoc_state<_Rp>* __state_; 910 911 explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp>* __state); 912 913 template <class> 914 friend class promise; 915 template <class> 916 friend class shared_future; 917 918 template <class _R1, class _Fp> 919 friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); 920 template <class _R1, class _Fp> 921 friend future<_R1> __make_async_assoc_state(_Fp&& __f); 922 923public: 924 _LIBCPP_HIDE_FROM_ABI future() _NOEXCEPT : __state_(nullptr) {} 925 _LIBCPP_HIDE_FROM_ABI future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; } 926 future(const future&) = delete; 927 future& operator=(const future&) = delete; 928 _LIBCPP_HIDE_FROM_ABI future& operator=(future&& __rhs) _NOEXCEPT { 929 future(std::move(__rhs)).swap(*this); 930 return *this; 931 } 932 933 _LIBCPP_HIDE_FROM_ABI ~future(); 934 _LIBCPP_HIDE_FROM_ABI shared_future<_Rp> share() _NOEXCEPT; 935 936 // retrieving the value 937 _LIBCPP_HIDE_FROM_ABI _Rp get(); 938 939 _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); } 940 941 // functions to check state 942 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; } 943 944 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); } 945 template <class _Rep, class _Period> 946 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const { 947 return __state_->wait_for(__rel_time); 948 } 949 template <class _Clock, class _Duration> 950 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const { 951 return __state_->wait_until(__abs_time); 952 } 953}; 954 955template <class _Rp> 956future<_Rp>::future(__assoc_state<_Rp>* __state) : __state_(__state) { 957 __state_->__attach_future(); 958} 959 960struct __release_shared_count { 961 _LIBCPP_HIDE_FROM_ABI void operator()(__shared_count* __p) { __p->__release_shared(); } 962}; 963 964template <class _Rp> 965future<_Rp>::~future() { 966 if (__state_) 967 __state_->__release_shared(); 968} 969 970template <class _Rp> 971_Rp future<_Rp>::get() { 972 unique_ptr<__shared_count, __release_shared_count> __guard(__state_); 973 __assoc_state<_Rp>* __s = __state_; 974 __state_ = nullptr; 975 return __s->move(); 976} 977 978template <class _Rp> 979class _LIBCPP_TEMPLATE_VIS future<_Rp&> { 980 __assoc_state<_Rp&>* __state_; 981 982 explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp&>* __state); 983 984 template <class> 985 friend class promise; 986 template <class> 987 friend class shared_future; 988 989 template <class _R1, class _Fp> 990 friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); 991 template <class _R1, class _Fp> 992 friend future<_R1> __make_async_assoc_state(_Fp&& __f); 993 994public: 995 _LIBCPP_HIDE_FROM_ABI future() _NOEXCEPT : __state_(nullptr) {} 996 _LIBCPP_HIDE_FROM_ABI future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; } 997 future(const future&) = delete; 998 future& operator=(const future&) = delete; 999 _LIBCPP_HIDE_FROM_ABI future& operator=(future&& __rhs) _NOEXCEPT { 1000 future(std::move(__rhs)).swap(*this); 1001 return *this; 1002 } 1003 1004 _LIBCPP_HIDE_FROM_ABI ~future(); 1005 _LIBCPP_HIDE_FROM_ABI shared_future<_Rp&> share() _NOEXCEPT; 1006 1007 // retrieving the value 1008 _LIBCPP_HIDE_FROM_ABI _Rp& get(); 1009 1010 _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); } 1011 1012 // functions to check state 1013 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; } 1014 1015 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); } 1016 template <class _Rep, class _Period> 1017 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const { 1018 return __state_->wait_for(__rel_time); 1019 } 1020 template <class _Clock, class _Duration> 1021 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const { 1022 return __state_->wait_until(__abs_time); 1023 } 1024}; 1025 1026template <class _Rp> 1027future<_Rp&>::future(__assoc_state<_Rp&>* __state) : __state_(__state) { 1028 __state_->__attach_future(); 1029} 1030 1031template <class _Rp> 1032future<_Rp&>::~future() { 1033 if (__state_) 1034 __state_->__release_shared(); 1035} 1036 1037template <class _Rp> 1038_Rp& future<_Rp&>::get() { 1039 unique_ptr<__shared_count, __release_shared_count> __guard(__state_); 1040 __assoc_state<_Rp&>* __s = __state_; 1041 __state_ = nullptr; 1042 return __s->copy(); 1043} 1044 1045template <> 1046class _LIBCPP_EXPORTED_FROM_ABI future<void> { 1047 __assoc_sub_state* __state_; 1048 1049 explicit future(__assoc_sub_state* __state); 1050 1051 template <class> 1052 friend class promise; 1053 template <class> 1054 friend class shared_future; 1055 1056 template <class _R1, class _Fp> 1057 friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); 1058 template <class _R1, class _Fp> 1059 friend future<_R1> __make_async_assoc_state(_Fp&& __f); 1060 1061public: 1062 _LIBCPP_HIDE_FROM_ABI future() _NOEXCEPT : __state_(nullptr) {} 1063 _LIBCPP_HIDE_FROM_ABI future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; } 1064 future(const future&) = delete; 1065 future& operator=(const future&) = delete; 1066 _LIBCPP_HIDE_FROM_ABI future& operator=(future&& __rhs) _NOEXCEPT { 1067 future(std::move(__rhs)).swap(*this); 1068 return *this; 1069 } 1070 1071 ~future(); 1072 _LIBCPP_HIDE_FROM_ABI shared_future<void> share() _NOEXCEPT; 1073 1074 // retrieving the value 1075 void get(); 1076 1077 _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); } 1078 1079 // functions to check state 1080 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; } 1081 1082 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); } 1083 template <class _Rep, class _Period> 1084 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const { 1085 return __state_->wait_for(__rel_time); 1086 } 1087 template <class _Clock, class _Duration> 1088 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const { 1089 return __state_->wait_until(__abs_time); 1090 } 1091}; 1092 1093template <class _Rp> 1094inline _LIBCPP_HIDE_FROM_ABI void swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT { 1095 __x.swap(__y); 1096} 1097 1098// promise<R> 1099 1100template <class _Callable> 1101class packaged_task; 1102 1103template <class _Rp> 1104class _LIBCPP_TEMPLATE_VIS promise { 1105 __assoc_state<_Rp>* __state_; 1106 1107 _LIBCPP_HIDE_FROM_ABI explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {} 1108 1109 template <class> 1110 friend class packaged_task; 1111 1112public: 1113 _LIBCPP_HIDE_FROM_ABI promise(); 1114 template <class _Alloc> 1115 _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Alloc& __a); 1116 _LIBCPP_HIDE_FROM_ABI promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; } 1117 promise(const promise& __rhs) = delete; 1118 _LIBCPP_HIDE_FROM_ABI ~promise(); 1119 1120 // assignment 1121 _LIBCPP_HIDE_FROM_ABI promise& operator=(promise&& __rhs) _NOEXCEPT { 1122 promise(std::move(__rhs)).swap(*this); 1123 return *this; 1124 } 1125 promise& operator=(const promise& __rhs) = delete; 1126 1127 _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); } 1128 1129 // retrieving the result 1130 _LIBCPP_HIDE_FROM_ABI future<_Rp> get_future(); 1131 1132 // setting the result 1133 _LIBCPP_HIDE_FROM_ABI void set_value(const _Rp& __r); 1134 _LIBCPP_HIDE_FROM_ABI void set_value(_Rp&& __r); 1135 _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p); 1136 1137 // setting the result with deferred notification 1138 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(const _Rp& __r); 1139 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&& __r); 1140 _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p); 1141}; 1142 1143template <class _Rp> 1144promise<_Rp>::promise() : __state_(new __assoc_state<_Rp>) {} 1145 1146template <class _Rp> 1147template <class _Alloc> 1148promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0) { 1149 typedef __assoc_state_alloc<_Rp, _Alloc> _State; 1150 typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2; 1151 typedef __allocator_destructor<_A2> _D2; 1152 _A2 __a(__a0); 1153 unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1)); 1154 ::new ((void*)std::addressof(*__hold.get())) _State(__a0); 1155 __state_ = std::addressof(*__hold.release()); 1156} 1157 1158template <class _Rp> 1159promise<_Rp>::~promise() { 1160 if (__state_) { 1161 if (!__state_->__has_value() && __state_->use_count() > 1) 1162 __state_->set_exception(make_exception_ptr(future_error(make_error_code(future_errc::broken_promise)))); 1163 __state_->__release_shared(); 1164 } 1165} 1166 1167template <class _Rp> 1168future<_Rp> promise<_Rp>::get_future() { 1169 if (__state_ == nullptr) 1170 __throw_future_error(future_errc::no_state); 1171 return future<_Rp>(__state_); 1172} 1173 1174template <class _Rp> 1175void promise<_Rp>::set_value(const _Rp& __r) { 1176 if (__state_ == nullptr) 1177 __throw_future_error(future_errc::no_state); 1178 __state_->set_value(__r); 1179} 1180 1181template <class _Rp> 1182void promise<_Rp>::set_value(_Rp&& __r) { 1183 if (__state_ == nullptr) 1184 __throw_future_error(future_errc::no_state); 1185 __state_->set_value(std::move(__r)); 1186} 1187 1188template <class _Rp> 1189void promise<_Rp>::set_exception(exception_ptr __p) { 1190 _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception: received nullptr"); 1191 if (__state_ == nullptr) 1192 __throw_future_error(future_errc::no_state); 1193 __state_->set_exception(__p); 1194} 1195 1196template <class _Rp> 1197void promise<_Rp>::set_value_at_thread_exit(const _Rp& __r) { 1198 if (__state_ == nullptr) 1199 __throw_future_error(future_errc::no_state); 1200 __state_->set_value_at_thread_exit(__r); 1201} 1202 1203template <class _Rp> 1204void promise<_Rp>::set_value_at_thread_exit(_Rp&& __r) { 1205 if (__state_ == nullptr) 1206 __throw_future_error(future_errc::no_state); 1207 __state_->set_value_at_thread_exit(std::move(__r)); 1208} 1209 1210template <class _Rp> 1211void promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p) { 1212 _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception_at_thread_exit: received nullptr"); 1213 if (__state_ == nullptr) 1214 __throw_future_error(future_errc::no_state); 1215 __state_->set_exception_at_thread_exit(__p); 1216} 1217 1218// promise<R&> 1219 1220template <class _Rp> 1221class _LIBCPP_TEMPLATE_VIS promise<_Rp&> { 1222 __assoc_state<_Rp&>* __state_; 1223 1224 _LIBCPP_HIDE_FROM_ABI explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {} 1225 1226 template <class> 1227 friend class packaged_task; 1228 1229public: 1230 _LIBCPP_HIDE_FROM_ABI promise(); 1231 template <class _Allocator> 1232 _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Allocator& __a); 1233 _LIBCPP_HIDE_FROM_ABI promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; } 1234 promise(const promise& __rhs) = delete; 1235 _LIBCPP_HIDE_FROM_ABI ~promise(); 1236 1237 // assignment 1238 _LIBCPP_HIDE_FROM_ABI promise& operator=(promise&& __rhs) _NOEXCEPT { 1239 promise(std::move(__rhs)).swap(*this); 1240 return *this; 1241 } 1242 promise& operator=(const promise& __rhs) = delete; 1243 1244 _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); } 1245 1246 // retrieving the result 1247 _LIBCPP_HIDE_FROM_ABI future<_Rp&> get_future(); 1248 1249 // setting the result 1250 _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __r); 1251 _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p); 1252 1253 // setting the result with deferred notification 1254 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&); 1255 _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p); 1256}; 1257 1258template <class _Rp> 1259promise<_Rp&>::promise() : __state_(new __assoc_state<_Rp&>) {} 1260 1261template <class _Rp> 1262template <class _Alloc> 1263promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0) { 1264 typedef __assoc_state_alloc<_Rp&, _Alloc> _State; 1265 typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2; 1266 typedef __allocator_destructor<_A2> _D2; 1267 _A2 __a(__a0); 1268 unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1)); 1269 ::new ((void*)std::addressof(*__hold.get())) _State(__a0); 1270 __state_ = std::addressof(*__hold.release()); 1271} 1272 1273template <class _Rp> 1274promise<_Rp&>::~promise() { 1275 if (__state_) { 1276 if (!__state_->__has_value() && __state_->use_count() > 1) 1277 __state_->set_exception(make_exception_ptr(future_error(make_error_code(future_errc::broken_promise)))); 1278 __state_->__release_shared(); 1279 } 1280} 1281 1282template <class _Rp> 1283future<_Rp&> promise<_Rp&>::get_future() { 1284 if (__state_ == nullptr) 1285 __throw_future_error(future_errc::no_state); 1286 return future<_Rp&>(__state_); 1287} 1288 1289template <class _Rp> 1290void promise<_Rp&>::set_value(_Rp& __r) { 1291 if (__state_ == nullptr) 1292 __throw_future_error(future_errc::no_state); 1293 __state_->set_value(__r); 1294} 1295 1296template <class _Rp> 1297void promise<_Rp&>::set_exception(exception_ptr __p) { 1298 _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception: received nullptr"); 1299 if (__state_ == nullptr) 1300 __throw_future_error(future_errc::no_state); 1301 __state_->set_exception(__p); 1302} 1303 1304template <class _Rp> 1305void promise<_Rp&>::set_value_at_thread_exit(_Rp& __r) { 1306 if (__state_ == nullptr) 1307 __throw_future_error(future_errc::no_state); 1308 __state_->set_value_at_thread_exit(__r); 1309} 1310 1311template <class _Rp> 1312void promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p) { 1313 _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception_at_thread_exit: received nullptr"); 1314 if (__state_ == nullptr) 1315 __throw_future_error(future_errc::no_state); 1316 __state_->set_exception_at_thread_exit(__p); 1317} 1318 1319// promise<void> 1320 1321template <> 1322class _LIBCPP_EXPORTED_FROM_ABI promise<void> { 1323 __assoc_sub_state* __state_; 1324 1325 _LIBCPP_HIDE_FROM_ABI explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {} 1326 1327 template <class> 1328 friend class packaged_task; 1329 1330public: 1331 promise(); 1332 template <class _Allocator> 1333 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS promise(allocator_arg_t, const _Allocator& __a); 1334 _LIBCPP_HIDE_FROM_ABI promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; } 1335 promise(const promise& __rhs) = delete; 1336 ~promise(); 1337 1338 // assignment 1339 _LIBCPP_HIDE_FROM_ABI promise& operator=(promise&& __rhs) _NOEXCEPT { 1340 promise(std::move(__rhs)).swap(*this); 1341 return *this; 1342 } 1343 promise& operator=(const promise& __rhs) = delete; 1344 1345 _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); } 1346 1347 // retrieving the result 1348 future<void> get_future(); 1349 1350 // setting the result 1351 void set_value(); 1352 void set_exception(exception_ptr __p); 1353 1354 // setting the result with deferred notification 1355 void set_value_at_thread_exit(); 1356 void set_exception_at_thread_exit(exception_ptr __p); 1357}; 1358 1359template <class _Alloc> 1360promise<void>::promise(allocator_arg_t, const _Alloc& __a0) { 1361 typedef __assoc_sub_state_alloc<_Alloc> _State; 1362 typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2; 1363 typedef __allocator_destructor<_A2> _D2; 1364 _A2 __a(__a0); 1365 unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1)); 1366 ::new ((void*)std::addressof(*__hold.get())) _State(__a0); 1367 __state_ = std::addressof(*__hold.release()); 1368} 1369 1370template <class _Rp> 1371inline _LIBCPP_HIDE_FROM_ABI void swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT { 1372 __x.swap(__y); 1373} 1374 1375template <class _Rp, class _Alloc> 1376struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc> : public true_type {}; 1377 1378// packaged_task 1379 1380template <class _Fp> 1381class __packaged_task_base; 1382 1383template <class _Rp, class... _ArgTypes> 1384class __packaged_task_base<_Rp(_ArgTypes...)> { 1385public: 1386 _LIBCPP_HIDE_FROM_ABI __packaged_task_base() {} 1387 __packaged_task_base(const __packaged_task_base&) = delete; 1388 __packaged_task_base& operator=(const __packaged_task_base&) = delete; 1389 _LIBCPP_HIDE_FROM_ABI_VIRTUAL 1390 virtual ~__packaged_task_base() {} 1391 virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0; 1392 virtual void destroy() = 0; 1393 virtual void destroy_deallocate() = 0; 1394 virtual _Rp operator()(_ArgTypes&&...) = 0; 1395}; 1396 1397template <class _FD, class _Alloc, class _FB> 1398class __packaged_task_func; 1399 1400template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes> 1401class __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)> : public __packaged_task_base<_Rp(_ArgTypes...)> { 1402 __compressed_pair<_Fp, _Alloc> __f_; 1403 1404public: 1405 _LIBCPP_HIDE_FROM_ABI explicit __packaged_task_func(const _Fp& __f) : __f_(__f, __default_init_tag()) {} 1406 _LIBCPP_HIDE_FROM_ABI explicit __packaged_task_func(_Fp&& __f) : __f_(std::move(__f), __default_init_tag()) {} 1407 _LIBCPP_HIDE_FROM_ABI __packaged_task_func(const _Fp& __f, const _Alloc& __a) : __f_(__f, __a) {} 1408 _LIBCPP_HIDE_FROM_ABI __packaged_task_func(_Fp&& __f, const _Alloc& __a) : __f_(std::move(__f), __a) {} 1409 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT; 1410 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy(); 1411 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy_deallocate(); 1412 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual _Rp operator()(_ArgTypes&&... __args); 1413}; 1414 1415template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes> 1416void __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to( 1417 __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT { 1418 ::new ((void*)__p) __packaged_task_func(std::move(__f_.first()), std::move(__f_.second())); 1419} 1420 1421template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes> 1422void __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() { 1423 __f_.~__compressed_pair<_Fp, _Alloc>(); 1424} 1425 1426template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes> 1427void __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() { 1428 typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap; 1429 typedef allocator_traits<_Ap> _ATraits; 1430 typedef pointer_traits<typename _ATraits::pointer> _PTraits; 1431 _Ap __a(__f_.second()); 1432 __f_.~__compressed_pair<_Fp, _Alloc>(); 1433 __a.deallocate(_PTraits::pointer_to(*this), 1); 1434} 1435 1436template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes> 1437_Rp __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&&... __arg) { 1438 return std::__invoke(__f_.first(), std::forward<_ArgTypes>(__arg)...); 1439} 1440 1441template <class _Callable> 1442class __packaged_task_function; 1443 1444template <class _Rp, class... _ArgTypes> 1445class __packaged_task_function<_Rp(_ArgTypes...)> { 1446 typedef __packaged_task_base<_Rp(_ArgTypes...)> __base; 1447 1448 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI __base* __get_buf() { return (__base*)&__buf_; } 1449 1450 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 1451 typename aligned_storage<3 * sizeof(void*)>::type __buf_; 1452 _LIBCPP_SUPPRESS_DEPRECATED_POP 1453 __base* __f_; 1454 1455public: 1456 typedef _Rp result_type; 1457 1458 // construct/copy/destroy: 1459 _LIBCPP_HIDE_FROM_ABI __packaged_task_function() _NOEXCEPT : __f_(nullptr) {} 1460 template <class _Fp> 1461 _LIBCPP_HIDE_FROM_ABI __packaged_task_function(_Fp&& __f); 1462 template <class _Fp, class _Alloc> 1463 _LIBCPP_HIDE_FROM_ABI __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f); 1464 1465 _LIBCPP_HIDE_FROM_ABI __packaged_task_function(__packaged_task_function&&) _NOEXCEPT; 1466 _LIBCPP_HIDE_FROM_ABI __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT; 1467 1468 __packaged_task_function(const __packaged_task_function&) = delete; 1469 __packaged_task_function& operator=(const __packaged_task_function&) = delete; 1470 1471 _LIBCPP_HIDE_FROM_ABI ~__packaged_task_function(); 1472 1473 _LIBCPP_HIDE_FROM_ABI void swap(__packaged_task_function&) _NOEXCEPT; 1474 1475 _LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes...) const; 1476}; 1477 1478template <class _Rp, class... _ArgTypes> 1479__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT { 1480 if (__f.__f_ == nullptr) 1481 __f_ = nullptr; 1482 else if (__f.__f_ == __f.__get_buf()) { 1483 __f.__f_->__move_to(__get_buf()); 1484 __f_ = (__base*)&__buf_; 1485 } else { 1486 __f_ = __f.__f_; 1487 __f.__f_ = nullptr; 1488 } 1489} 1490 1491template <class _Rp, class... _ArgTypes> 1492template <class _Fp> 1493__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f) : __f_(nullptr) { 1494 typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR; 1495 typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF; 1496 if (sizeof(_FF) <= sizeof(__buf_)) { 1497 ::new ((void*)&__buf_) _FF(std::forward<_Fp>(__f)); 1498 __f_ = (__base*)&__buf_; 1499 } else { 1500 typedef allocator<_FF> _Ap; 1501 _Ap __a; 1502 typedef __allocator_destructor<_Ap> _Dp; 1503 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1504 ::new ((void*)__hold.get()) _FF(std::forward<_Fp>(__f), allocator<_FR>(__a)); 1505 __f_ = __hold.release(); 1506 } 1507} 1508 1509template <class _Rp, class... _ArgTypes> 1510template <class _Fp, class _Alloc> 1511__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(allocator_arg_t, const _Alloc& __a0, _Fp&& __f) 1512 : __f_(nullptr) { 1513 typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR; 1514 typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF; 1515 if (sizeof(_FF) <= sizeof(__buf_)) { 1516 __f_ = (__base*)&__buf_; 1517 ::new ((void*)__f_) _FF(std::forward<_Fp>(__f)); 1518 } else { 1519 typedef typename __allocator_traits_rebind<_Alloc, _FF>::type _Ap; 1520 _Ap __a(__a0); 1521 typedef __allocator_destructor<_Ap> _Dp; 1522 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1523 ::new ((void*)std::addressof(*__hold.get())) _FF(std::forward<_Fp>(__f), _Alloc(__a)); 1524 __f_ = std::addressof(*__hold.release()); 1525 } 1526} 1527 1528template <class _Rp, class... _ArgTypes> 1529__packaged_task_function<_Rp(_ArgTypes...)>& 1530__packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT { 1531 if (__f_ == __get_buf()) 1532 __f_->destroy(); 1533 else if (__f_) 1534 __f_->destroy_deallocate(); 1535 __f_ = nullptr; 1536 if (__f.__f_ == nullptr) 1537 __f_ = nullptr; 1538 else if (__f.__f_ == __f.__get_buf()) { 1539 __f.__f_->__move_to(__get_buf()); 1540 __f_ = __get_buf(); 1541 } else { 1542 __f_ = __f.__f_; 1543 __f.__f_ = nullptr; 1544 } 1545 return *this; 1546} 1547 1548template <class _Rp, class... _ArgTypes> 1549__packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function() { 1550 if (__f_ == __get_buf()) 1551 __f_->destroy(); 1552 else if (__f_) 1553 __f_->destroy_deallocate(); 1554} 1555 1556template <class _Rp, class... _ArgTypes> 1557_LIBCPP_NO_CFI void __packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT { 1558 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) { 1559 _LIBCPP_SUPPRESS_DEPRECATED_PUSH 1560 typename aligned_storage<sizeof(__buf_)>::type __tempbuf; 1561 _LIBCPP_SUPPRESS_DEPRECATED_POP 1562 __base* __t = (__base*)&__tempbuf; 1563 __f_->__move_to(__t); 1564 __f_->destroy(); 1565 __f_ = nullptr; 1566 __f.__f_->__move_to((__base*)&__buf_); 1567 __f.__f_->destroy(); 1568 __f.__f_ = nullptr; 1569 __f_ = (__base*)&__buf_; 1570 __t->__move_to((__base*)&__f.__buf_); 1571 __t->destroy(); 1572 __f.__f_ = (__base*)&__f.__buf_; 1573 } else if (__f_ == (__base*)&__buf_) { 1574 __f_->__move_to((__base*)&__f.__buf_); 1575 __f_->destroy(); 1576 __f_ = __f.__f_; 1577 __f.__f_ = (__base*)&__f.__buf_; 1578 } else if (__f.__f_ == (__base*)&__f.__buf_) { 1579 __f.__f_->__move_to((__base*)&__buf_); 1580 __f.__f_->destroy(); 1581 __f.__f_ = __f_; 1582 __f_ = (__base*)&__buf_; 1583 } else 1584 std::swap(__f_, __f.__f_); 1585} 1586 1587template <class _Rp, class... _ArgTypes> 1588inline _Rp __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const { 1589 return (*__f_)(std::forward<_ArgTypes>(__arg)...); 1590} 1591 1592template <class _Rp, class... _ArgTypes> 1593class _LIBCPP_TEMPLATE_VIS packaged_task<_Rp(_ArgTypes...)> { 1594public: 1595 typedef _Rp result_type; // extension 1596 1597private: 1598 __packaged_task_function<result_type(_ArgTypes...)> __f_; 1599 promise<result_type> __p_; 1600 1601public: 1602 // construction and destruction 1603 _LIBCPP_HIDE_FROM_ABI packaged_task() _NOEXCEPT : __p_(nullptr) {} 1604 1605 template <class _Fp, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0> 1606 _LIBCPP_HIDE_FROM_ABI explicit packaged_task(_Fp&& __f) : __f_(std::forward<_Fp>(__f)) {} 1607 1608 template <class _Fp, class _Allocator, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0> 1609 _LIBCPP_HIDE_FROM_ABI packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) 1610 : __f_(allocator_arg_t(), __a, std::forward<_Fp>(__f)), __p_(allocator_arg_t(), __a) {} 1611 // ~packaged_task() = default; 1612 1613 // no copy 1614 packaged_task(const packaged_task&) = delete; 1615 packaged_task& operator=(const packaged_task&) = delete; 1616 1617 // move support 1618 _LIBCPP_HIDE_FROM_ABI packaged_task(packaged_task&& __other) _NOEXCEPT 1619 : __f_(std::move(__other.__f_)), 1620 __p_(std::move(__other.__p_)) {} 1621 _LIBCPP_HIDE_FROM_ABI packaged_task& operator=(packaged_task&& __other) _NOEXCEPT { 1622 __f_ = std::move(__other.__f_); 1623 __p_ = std::move(__other.__p_); 1624 return *this; 1625 } 1626 _LIBCPP_HIDE_FROM_ABI void swap(packaged_task& __other) _NOEXCEPT { 1627 __f_.swap(__other.__f_); 1628 __p_.swap(__other.__p_); 1629 } 1630 1631 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; } 1632 1633 // result retrieval 1634 _LIBCPP_HIDE_FROM_ABI future<result_type> get_future() { return __p_.get_future(); } 1635 1636 // execution 1637 _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args); 1638 _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args); 1639 1640 _LIBCPP_HIDE_FROM_ABI void reset(); 1641}; 1642 1643template <class _Rp, class... _ArgTypes> 1644void packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args) { 1645 if (__p_.__state_ == nullptr) 1646 __throw_future_error(future_errc::no_state); 1647 if (__p_.__state_->__has_value()) 1648 __throw_future_error(future_errc::promise_already_satisfied); 1649# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1650 try { 1651# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1652 __p_.set_value(__f_(std::forward<_ArgTypes>(__args)...)); 1653# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1654 } catch (...) { 1655 __p_.set_exception(current_exception()); 1656 } 1657# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1658} 1659 1660template <class _Rp, class... _ArgTypes> 1661void packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) { 1662 if (__p_.__state_ == nullptr) 1663 __throw_future_error(future_errc::no_state); 1664 if (__p_.__state_->__has_value()) 1665 __throw_future_error(future_errc::promise_already_satisfied); 1666# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1667 try { 1668# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1669 __p_.set_value_at_thread_exit(__f_(std::forward<_ArgTypes>(__args)...)); 1670# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1671 } catch (...) { 1672 __p_.set_exception_at_thread_exit(current_exception()); 1673 } 1674# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1675} 1676 1677template <class _Rp, class... _ArgTypes> 1678void packaged_task<_Rp(_ArgTypes...)>::reset() { 1679 if (!valid()) 1680 __throw_future_error(future_errc::no_state); 1681 __p_ = promise<result_type>(); 1682} 1683 1684template <class... _ArgTypes> 1685class _LIBCPP_TEMPLATE_VIS packaged_task<void(_ArgTypes...)> { 1686public: 1687 typedef void result_type; // extension 1688 1689private: 1690 __packaged_task_function<result_type(_ArgTypes...)> __f_; 1691 promise<result_type> __p_; 1692 1693public: 1694 // construction and destruction 1695 _LIBCPP_HIDE_FROM_ABI packaged_task() _NOEXCEPT : __p_(nullptr) {} 1696 template <class _Fp, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0> 1697 _LIBCPP_HIDE_FROM_ABI explicit packaged_task(_Fp&& __f) : __f_(std::forward<_Fp>(__f)) {} 1698 template <class _Fp, class _Allocator, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0> 1699 _LIBCPP_HIDE_FROM_ABI packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) 1700 : __f_(allocator_arg_t(), __a, std::forward<_Fp>(__f)), __p_(allocator_arg_t(), __a) {} 1701 // ~packaged_task() = default; 1702 1703 // no copy 1704 packaged_task(const packaged_task&) = delete; 1705 packaged_task& operator=(const packaged_task&) = delete; 1706 1707 // move support 1708 _LIBCPP_HIDE_FROM_ABI packaged_task(packaged_task&& __other) _NOEXCEPT 1709 : __f_(std::move(__other.__f_)), 1710 __p_(std::move(__other.__p_)) {} 1711 _LIBCPP_HIDE_FROM_ABI packaged_task& operator=(packaged_task&& __other) _NOEXCEPT { 1712 __f_ = std::move(__other.__f_); 1713 __p_ = std::move(__other.__p_); 1714 return *this; 1715 } 1716 _LIBCPP_HIDE_FROM_ABI void swap(packaged_task& __other) _NOEXCEPT { 1717 __f_.swap(__other.__f_); 1718 __p_.swap(__other.__p_); 1719 } 1720 1721 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; } 1722 1723 // result retrieval 1724 _LIBCPP_HIDE_FROM_ABI future<result_type> get_future() { return __p_.get_future(); } 1725 1726 // execution 1727 _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args); 1728 _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args); 1729 1730 _LIBCPP_HIDE_FROM_ABI void reset(); 1731}; 1732 1733# if _LIBCPP_STD_VER >= 17 1734 1735template <class _Rp, class... _Args> 1736packaged_task(_Rp (*)(_Args...)) -> packaged_task<_Rp(_Args...)>; 1737 1738template <class _Fp, class _Stripped = typename __strip_signature<decltype(&_Fp::operator())>::type> 1739packaged_task(_Fp) -> packaged_task<_Stripped>; 1740 1741# endif 1742 1743template <class... _ArgTypes> 1744void packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args) { 1745 if (__p_.__state_ == nullptr) 1746 __throw_future_error(future_errc::no_state); 1747 if (__p_.__state_->__has_value()) 1748 __throw_future_error(future_errc::promise_already_satisfied); 1749# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1750 try { 1751# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1752 __f_(std::forward<_ArgTypes>(__args)...); 1753 __p_.set_value(); 1754# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1755 } catch (...) { 1756 __p_.set_exception(current_exception()); 1757 } 1758# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1759} 1760 1761template <class... _ArgTypes> 1762void packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) { 1763 if (__p_.__state_ == nullptr) 1764 __throw_future_error(future_errc::no_state); 1765 if (__p_.__state_->__has_value()) 1766 __throw_future_error(future_errc::promise_already_satisfied); 1767# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1768 try { 1769# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1770 __f_(std::forward<_ArgTypes>(__args)...); 1771 __p_.set_value_at_thread_exit(); 1772# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1773 } catch (...) { 1774 __p_.set_exception_at_thread_exit(current_exception()); 1775 } 1776# endif // _LIBCPP_HAS_NO_EXCEPTIONS 1777} 1778 1779template <class... _ArgTypes> 1780void packaged_task<void(_ArgTypes...)>::reset() { 1781 if (!valid()) 1782 __throw_future_error(future_errc::no_state); 1783 __p_ = promise<result_type>(); 1784} 1785 1786template <class _Rp, class... _ArgTypes> 1787inline _LIBCPP_HIDE_FROM_ABI void 1788swap(packaged_task<_Rp(_ArgTypes...)>& __x, packaged_task<_Rp(_ArgTypes...)>& __y) _NOEXCEPT { 1789 __x.swap(__y); 1790} 1791 1792template <class _Callable, class _Alloc> 1793struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc> : public true_type {}; 1794 1795template <class _Rp, class _Fp> 1796_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_deferred_assoc_state(_Fp&& __f) { 1797 unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count> __h( 1798 new __deferred_assoc_state<_Rp, _Fp>(std::forward<_Fp>(__f))); 1799 return future<_Rp>(__h.get()); 1800} 1801 1802template <class _Rp, class _Fp> 1803_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_async_assoc_state(_Fp&& __f) { 1804 unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count> __h( 1805 new __async_assoc_state<_Rp, _Fp>(std::forward<_Fp>(__f))); 1806 std::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach(); 1807 return future<_Rp>(__h.get()); 1808} 1809 1810# ifndef _LIBCPP_CXX03_LANG 1811 1812template <class _Fp, class... _Args> 1813class _LIBCPP_HIDDEN __async_func { 1814 tuple<_Fp, _Args...> __f_; 1815 1816public: 1817 typedef typename __invoke_of<_Fp, _Args...>::type _Rp; 1818 1819 _LIBCPP_HIDE_FROM_ABI explicit __async_func(_Fp&& __f, _Args&&... __args) 1820 : __f_(std::move(__f), std::move(__args)...) {} 1821 1822 _LIBCPP_HIDE_FROM_ABI __async_func(__async_func&& __f) : __f_(std::move(__f.__f_)) {} 1823 1824 _LIBCPP_HIDE_FROM_ABI _Rp operator()() { 1825 typedef typename __make_tuple_indices<1 + sizeof...(_Args), 1>::type _Index; 1826 return __execute(_Index()); 1827 } 1828 1829private: 1830 template <size_t... _Indices> 1831 _LIBCPP_HIDE_FROM_ABI _Rp __execute(__tuple_indices<_Indices...>) { 1832 return std::__invoke(std::move(std::get<0>(__f_)), std::move(std::get<_Indices>(__f_))...); 1833 } 1834}; 1835 1836inline _LIBCPP_HIDE_FROM_ABI bool __does_policy_contain(launch __policy, launch __value) { 1837 return (int(__policy) & int(__value)) != 0; 1838} 1839 1840template <class _Fp, class... _Args> 1841_LIBCPP_NODISCARD _LIBCPP_HIDE_FROM_ABI future<typename __invoke_of<__decay_t<_Fp>, __decay_t<_Args>...>::type> 1842async(launch __policy, _Fp&& __f, _Args&&... __args) { 1843 typedef __async_func<__decay_t<_Fp>, __decay_t<_Args>...> _BF; 1844 typedef typename _BF::_Rp _Rp; 1845 1846# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1847 try { 1848# endif 1849 if (__does_policy_contain(__policy, launch::async)) 1850 return std::__make_async_assoc_state<_Rp>( 1851 _BF(_LIBCPP_AUTO_CAST(std::forward<_Fp>(__f)), _LIBCPP_AUTO_CAST(std::forward<_Args>(__args))...)); 1852# ifndef _LIBCPP_HAS_NO_EXCEPTIONS 1853 } catch (...) { 1854 if (__policy == launch::async) 1855 throw; 1856 } 1857# endif 1858 1859 if (__does_policy_contain(__policy, launch::deferred)) 1860 return std::__make_deferred_assoc_state<_Rp>( 1861 _BF(_LIBCPP_AUTO_CAST(std::forward<_Fp>(__f)), _LIBCPP_AUTO_CAST(std::forward<_Args>(__args))...)); 1862 return future<_Rp>{}; 1863} 1864 1865template <class _Fp, class... _Args> 1866_LIBCPP_NODISCARD inline _LIBCPP_HIDE_FROM_ABI future<typename __invoke_of<__decay_t<_Fp>, __decay_t<_Args>...>::type> 1867async(_Fp&& __f, _Args&&... __args) { 1868 return std::async(launch::any, std::forward<_Fp>(__f), std::forward<_Args>(__args)...); 1869} 1870 1871# endif // C++03 1872 1873// shared_future 1874 1875template <class _Rp> 1876class _LIBCPP_TEMPLATE_VIS shared_future { 1877 __assoc_state<_Rp>* __state_; 1878 1879public: 1880 _LIBCPP_HIDE_FROM_ABI shared_future() _NOEXCEPT : __state_(nullptr) {} 1881 _LIBCPP_HIDE_FROM_ABI shared_future(const shared_future& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { 1882 if (__state_) 1883 __state_->__add_shared(); 1884 } 1885 _LIBCPP_HIDE_FROM_ABI shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_) { __f.__state_ = nullptr; } 1886 _LIBCPP_HIDE_FROM_ABI shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { 1887 __rhs.__state_ = nullptr; 1888 } 1889 _LIBCPP_HIDE_FROM_ABI ~shared_future(); 1890 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs) _NOEXCEPT; 1891 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(shared_future&& __rhs) _NOEXCEPT { 1892 shared_future(std::move(__rhs)).swap(*this); 1893 return *this; 1894 } 1895 1896 // retrieving the value 1897 _LIBCPP_HIDE_FROM_ABI const _Rp& get() const { return __state_->copy(); } 1898 1899 _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); } 1900 1901 // functions to check state 1902 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; } 1903 1904 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); } 1905 template <class _Rep, class _Period> 1906 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const { 1907 return __state_->wait_for(__rel_time); 1908 } 1909 template <class _Clock, class _Duration> 1910 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const { 1911 return __state_->wait_until(__abs_time); 1912 } 1913}; 1914 1915template <class _Rp> 1916shared_future<_Rp>::~shared_future() { 1917 if (__state_) 1918 __state_->__release_shared(); 1919} 1920 1921template <class _Rp> 1922shared_future<_Rp>& shared_future<_Rp>::operator=(const shared_future& __rhs) _NOEXCEPT { 1923 if (__rhs.__state_) 1924 __rhs.__state_->__add_shared(); 1925 if (__state_) 1926 __state_->__release_shared(); 1927 __state_ = __rhs.__state_; 1928 return *this; 1929} 1930 1931template <class _Rp> 1932class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&> { 1933 __assoc_state<_Rp&>* __state_; 1934 1935public: 1936 _LIBCPP_HIDE_FROM_ABI shared_future() _NOEXCEPT : __state_(nullptr) {} 1937 _LIBCPP_HIDE_FROM_ABI shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) { 1938 if (__state_) 1939 __state_->__add_shared(); 1940 } 1941 _LIBCPP_HIDE_FROM_ABI shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_) { __f.__state_ = nullptr; } 1942 _LIBCPP_HIDE_FROM_ABI shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { 1943 __rhs.__state_ = nullptr; 1944 } 1945 _LIBCPP_HIDE_FROM_ABI ~shared_future(); 1946 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs); 1947 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(shared_future&& __rhs) _NOEXCEPT { 1948 shared_future(std::move(__rhs)).swap(*this); 1949 return *this; 1950 } 1951 1952 // retrieving the value 1953 _LIBCPP_HIDE_FROM_ABI _Rp& get() const { return __state_->copy(); } 1954 1955 _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); } 1956 1957 // functions to check state 1958 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; } 1959 1960 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); } 1961 template <class _Rep, class _Period> 1962 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const { 1963 return __state_->wait_for(__rel_time); 1964 } 1965 template <class _Clock, class _Duration> 1966 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const { 1967 return __state_->wait_until(__abs_time); 1968 } 1969}; 1970 1971template <class _Rp> 1972shared_future<_Rp&>::~shared_future() { 1973 if (__state_) 1974 __state_->__release_shared(); 1975} 1976 1977template <class _Rp> 1978shared_future<_Rp&>& shared_future<_Rp&>::operator=(const shared_future& __rhs) { 1979 if (__rhs.__state_) 1980 __rhs.__state_->__add_shared(); 1981 if (__state_) 1982 __state_->__release_shared(); 1983 __state_ = __rhs.__state_; 1984 return *this; 1985} 1986 1987template <> 1988class _LIBCPP_EXPORTED_FROM_ABI shared_future<void> { 1989 __assoc_sub_state* __state_; 1990 1991public: 1992 _LIBCPP_HIDE_FROM_ABI shared_future() _NOEXCEPT : __state_(nullptr) {} 1993 _LIBCPP_HIDE_FROM_ABI shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) { 1994 if (__state_) 1995 __state_->__add_shared(); 1996 } 1997 _LIBCPP_HIDE_FROM_ABI shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_) { __f.__state_ = nullptr; } 1998 _LIBCPP_HIDE_FROM_ABI shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { 1999 __rhs.__state_ = nullptr; 2000 } 2001 ~shared_future(); 2002 shared_future& operator=(const shared_future& __rhs); 2003 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(shared_future&& __rhs) _NOEXCEPT { 2004 shared_future(std::move(__rhs)).swap(*this); 2005 return *this; 2006 } 2007 2008 // retrieving the value 2009 _LIBCPP_HIDE_FROM_ABI void get() const { __state_->copy(); } 2010 2011 _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); } 2012 2013 // functions to check state 2014 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; } 2015 2016 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); } 2017 template <class _Rep, class _Period> 2018 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const { 2019 return __state_->wait_for(__rel_time); 2020 } 2021 template <class _Clock, class _Duration> 2022 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const { 2023 return __state_->wait_until(__abs_time); 2024 } 2025}; 2026 2027template <class _Rp> 2028inline _LIBCPP_HIDE_FROM_ABI void swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT { 2029 __x.swap(__y); 2030} 2031 2032template <class _Rp> 2033inline shared_future<_Rp> future<_Rp>::share() _NOEXCEPT { 2034 return shared_future<_Rp>(std::move(*this)); 2035} 2036 2037template <class _Rp> 2038inline shared_future<_Rp&> future<_Rp&>::share() _NOEXCEPT { 2039 return shared_future<_Rp&>(std::move(*this)); 2040} 2041 2042inline shared_future<void> future<void>::share() _NOEXCEPT { return shared_future<void>(std::move(*this)); } 2043 2044_LIBCPP_END_NAMESPACE_STD 2045 2046_LIBCPP_POP_MACROS 2047 2048#endif // !defined(_LIBCPP_HAS_NO_THREADS) 2049 2050#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 17 2051# include <chrono> 2052#endif 2053 2054#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 2055# include <atomic> 2056# include <cstdlib> 2057# include <exception> 2058# include <iosfwd> 2059# include <system_error> 2060#endif 2061 2062#endif // _LIBCPP_FUTURE 2063