1947 lines · plain
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-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP___CXX03_FUTURE11#define _LIBCPP___CXX03_FUTURE12 13/*14 future synopsis15 16namespace std17{18 19enum class future_errc20{21 future_already_retrieved = 1,22 promise_already_satisfied,23 no_state,24 broken_promise25};26 27enum class launch28{29 async = 1,30 deferred = 2,31 any = async | deferred32};33 34enum class future_status35{36 ready,37 timeout,38 deferred39};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++1750 51 const error_code& code() const noexcept;52 const char* what() const noexcept;53 54private:55 error_code ec_; // exposition only56};57 58template <class R>59class promise60{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 // assignment70 promise& operator=(promise&& rhs) noexcept;71 promise& operator=(const promise& rhs) = delete;72 void swap(promise& other) noexcept;73 74 // retrieving the result75 future<R> get_future();76 77 // setting the result78 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 notification83 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 // assignment100 promise& operator=(promise&& rhs) noexcept;101 promise& operator=(const promise& rhs) = delete;102 void swap(promise& other) noexcept;103 104 // retrieving the result105 future<R&> get_future();106 107 // setting the result108 void set_value(R& r);109 void set_exception(exception_ptr p);110 111 // setting the result with deferred notification112 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 // assignment128 promise& operator=(promise&& rhs) noexcept;129 promise& operator=(const promise& rhs) = delete;130 void swap(promise& other) noexcept;131 132 // retrieving the result133 future<void> get_future();134 135 // setting the result136 void set_value();137 void set_exception(exception_ptr p);138 139 // setting the result with deferred notification140 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 future151{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 value162 R get();163 164 // functions to check state165 bool valid() const noexcept;166 167 void wait() const;168 template <class Rep, class Period>169 future_status170 wait_for(const chrono::duration<Rep, Period>& rel_time) const;171 template <class Clock, class Duration>172 future_status173 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 value189 R& get();190 191 // functions to check state192 bool valid() const noexcept;193 194 void wait() const;195 template <class Rep, class Period>196 future_status197 wait_for(const chrono::duration<Rep, Period>& rel_time) const;198 template <class Clock, class Duration>199 future_status200 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 value216 void get();217 218 // functions to check state219 bool valid() const noexcept;220 221 void wait() const;222 template <class Rep, class Period>223 future_status224 wait_for(const chrono::duration<Rep, Period>& rel_time) const;225 template <class Clock, class Duration>226 future_status227 wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;228};229 230template <class R>231class shared_future232{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 value243 const R& get() const;244 245 // functions to check state246 bool valid() const noexcept;247 248 void wait() const;249 template <class Rep, class Period>250 future_status251 wait_for(const chrono::duration<Rep, Period>& rel_time) const;252 template <class Clock, class Duration>253 future_status254 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 value270 R& get() const;271 272 // functions to check state273 bool valid() const noexcept;274 275 void wait() const;276 template <class Rep, class Period>277 future_status278 wait_for(const chrono::duration<Rep, Period>& rel_time) const;279 template <class Clock, class Duration>280 future_status281 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 value297 void get() const;298 299 // functions to check state300 bool valid() const noexcept;301 302 void wait() const;303 template <class Rep, class Period>304 future_status305 wait_for(const chrono::duration<Rep, Period>& rel_time) const;306 template <class Clock, class Duration>307 future_status308 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; // undefined320 321template <class R, class... ArgTypes>322class packaged_task<R(ArgTypes...)>323{324public:325 typedef R result_type; // extension326 327 // construction and destruction328 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 copy336 packaged_task(const packaged_task&) = delete;337 packaged_task& operator=(const packaged_task&) = delete;338 339 // move support340 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 retrieval347 future<R> get_future();348 349 // execution350 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} // std362 363*/364 365#include <__cxx03/__config>366 367#if !defined(_LIBCPP_HAS_NO_THREADS)368 369# include <__cxx03/__assert>370# include <__cxx03/__chrono/duration.h>371# include <__cxx03/__chrono/time_point.h>372# include <__cxx03/__exception/exception_ptr.h>373# include <__cxx03/__memory/addressof.h>374# include <__cxx03/__memory/allocator.h>375# include <__cxx03/__memory/allocator_arg_t.h>376# include <__cxx03/__memory/allocator_destructor.h>377# include <__cxx03/__memory/allocator_traits.h>378# include <__cxx03/__memory/compressed_pair.h>379# include <__cxx03/__memory/pointer_traits.h>380# include <__cxx03/__memory/shared_ptr.h>381# include <__cxx03/__memory/unique_ptr.h>382# include <__cxx03/__memory/uses_allocator.h>383# include <__cxx03/__system_error/error_category.h>384# include <__cxx03/__system_error/error_code.h>385# include <__cxx03/__system_error/error_condition.h>386# include <__cxx03/__type_traits/aligned_storage.h>387# include <__cxx03/__type_traits/strip_signature.h>388# include <__cxx03/__utility/auto_cast.h>389# include <__cxx03/__utility/forward.h>390# include <__cxx03/__utility/move.h>391# include <__cxx03/mutex>392# include <__cxx03/new>393# include <__cxx03/stdexcept>394# include <__cxx03/thread>395# include <__cxx03/version>396 397# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)398# pragma GCC system_header399# endif400 401_LIBCPP_PUSH_MACROS402# include <__cxx03/__undef_macros>403 404_LIBCPP_BEGIN_NAMESPACE_STD405 406// enum class future_errc407_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 414template <>415struct _LIBCPP_TEMPLATE_VIS is_error_code_enum<future_errc::__lx> : public true_type {};416 417// enum class launch418_LIBCPP_DECLARE_STRONG_ENUM(launch){async = 1, deferred = 2, any = async | deferred};419_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch)420 421// enum class future_status422_LIBCPP_DECLARE_STRONG_ENUM(future_status){ready, timeout, deferred};423_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)424 425_LIBCPP_EXPORTED_FROM_ABI const error_category& future_category() _NOEXCEPT;426 427inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(future_errc __e) _NOEXCEPT {428 return error_code(static_cast<int>(__e), future_category());429}430 431inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(future_errc __e) _NOEXCEPT {432 return error_condition(static_cast<int>(__e), future_category());433}434 435_LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_future_error(future_errc __ev);436 437class _LIBCPP_EXPORTED_FROM_ABI future_error : public logic_error {438 error_code __ec_;439 440 future_error(error_code);441 friend void __throw_future_error(future_errc);442 template <class>443 friend class promise;444 445public:446 _LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; }447 448 _LIBCPP_HIDE_FROM_ABI future_error(const future_error&) _NOEXCEPT = default;449 ~future_error() _NOEXCEPT override;450};451 452// Declared above std::future_error453void __throw_future_error(future_errc __ev) {454# ifndef _LIBCPP_HAS_NO_EXCEPTIONS455 throw future_error(make_error_code(__ev));456# else457 (void)__ev;458 _LIBCPP_VERBOSE_ABORT("future_error was thrown in -fno-exceptions mode");459# endif460}461 462class _LIBCPP_EXPORTED_FROM_ABI __assoc_sub_state : public __shared_count {463protected:464 exception_ptr __exception_;465 mutable mutex __mut_;466 mutable condition_variable __cv_;467 unsigned __state_;468 469 void __on_zero_shared() _NOEXCEPT override;470 void __sub_wait(unique_lock<mutex>& __lk);471 472public:473 enum { __constructed = 1, __future_attached = 2, ready = 4, deferred = 8 };474 475 _LIBCPP_HIDE_FROM_ABI __assoc_sub_state() : __state_(0) {}476 477 _LIBCPP_HIDE_FROM_ABI bool __has_value() const { return (__state_ & __constructed) || (__exception_ != nullptr); }478 479 _LIBCPP_HIDE_FROM_ABI void __attach_future() {480 lock_guard<mutex> __lk(__mut_);481 bool __has_future_attached = (__state_ & __future_attached) != 0;482 if (__has_future_attached)483 __throw_future_error(future_errc::future_already_retrieved);484 this->__add_shared();485 __state_ |= __future_attached;486 }487 488 _LIBCPP_HIDE_FROM_ABI void __set_deferred() { __state_ |= deferred; }489 490 void __make_ready();491 _LIBCPP_HIDE_FROM_ABI bool __is_ready() const { return (__state_ & ready) != 0; }492 493 void set_value();494 void set_value_at_thread_exit();495 496 void set_exception(exception_ptr __p);497 void set_exception_at_thread_exit(exception_ptr __p);498 499 void copy();500 501 void wait();502 template <class _Rep, class _Period>503 future_status _LIBCPP_HIDE_FROM_ABI wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const;504 template <class _Clock, class _Duration>505 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS future_status506 wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const;507 508 virtual void __execute();509};510 511template <class _Clock, class _Duration>512future_status __assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {513 unique_lock<mutex> __lk(__mut_);514 if (__state_ & deferred)515 return future_status::deferred;516 while (!(__state_ & ready) && _Clock::now() < __abs_time)517 __cv_.wait_until(__lk, __abs_time);518 if (__state_ & ready)519 return future_status::ready;520 return future_status::timeout;521}522 523template <class _Rep, class _Period>524inline future_status __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {525 return wait_until(chrono::steady_clock::now() + __rel_time);526}527 528template <class _Rp>529class _LIBCPP_HIDDEN __assoc_state : public __assoc_sub_state {530 typedef __assoc_sub_state base;531 _LIBCPP_SUPPRESS_DEPRECATED_PUSH532 typedef typename aligned_storage<sizeof(_Rp), _LIBCPP_ALIGNOF(_Rp)>::type _Up;533 _LIBCPP_SUPPRESS_DEPRECATED_POP534 535protected:536 _Up __value_;537 538 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;539 540public:541 template <class _Arg>542 _LIBCPP_HIDE_FROM_ABI void set_value(_Arg&& __arg);543 544 template <class _Arg>545 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Arg&& __arg);546 547 _LIBCPP_HIDE_FROM_ABI _Rp move();548 _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<_Rp> copy();549};550 551template <class _Rp>552void __assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT {553 if (this->__state_ & base::__constructed)554 reinterpret_cast<_Rp*>(&__value_)->~_Rp();555 delete this;556}557 558template <class _Rp>559template <class _Arg>560void __assoc_state<_Rp>::set_value(_Arg&& __arg) {561 unique_lock<mutex> __lk(this->__mut_);562 if (this->__has_value())563 __throw_future_error(future_errc::promise_already_satisfied);564 ::new ((void*)&__value_) _Rp(std::forward<_Arg>(__arg));565 this->__state_ |= base::__constructed | base::ready;566 __cv_.notify_all();567}568 569template <class _Rp>570template <class _Arg>571void __assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg) {572 unique_lock<mutex> __lk(this->__mut_);573 if (this->__has_value())574 __throw_future_error(future_errc::promise_already_satisfied);575 ::new ((void*)&__value_) _Rp(std::forward<_Arg>(__arg));576 this->__state_ |= base::__constructed;577 __thread_local_data()->__make_ready_at_thread_exit(this);578}579 580template <class _Rp>581_Rp __assoc_state<_Rp>::move() {582 unique_lock<mutex> __lk(this->__mut_);583 this->__sub_wait(__lk);584 if (this->__exception_ != nullptr)585 std::rethrow_exception(this->__exception_);586 return std::move(*reinterpret_cast<_Rp*>(&__value_));587}588 589template <class _Rp>590__add_lvalue_reference_t<_Rp> __assoc_state<_Rp>::copy() {591 unique_lock<mutex> __lk(this->__mut_);592 this->__sub_wait(__lk);593 if (this->__exception_ != nullptr)594 std::rethrow_exception(this->__exception_);595 return *reinterpret_cast<_Rp*>(&__value_);596}597 598template <class _Rp>599class __assoc_state<_Rp&> : public __assoc_sub_state {600 typedef __assoc_sub_state base;601 typedef _Rp* _Up;602 603protected:604 _Up __value_;605 606 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;607 608public:609 _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __arg);610 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp& __arg);611 612 _LIBCPP_HIDE_FROM_ABI _Rp& copy();613};614 615template <class _Rp>616void __assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT {617 delete this;618}619 620template <class _Rp>621void __assoc_state<_Rp&>::set_value(_Rp& __arg) {622 unique_lock<mutex> __lk(this->__mut_);623 if (this->__has_value())624 __throw_future_error(future_errc::promise_already_satisfied);625 __value_ = std::addressof(__arg);626 this->__state_ |= base::__constructed | base::ready;627 __cv_.notify_all();628}629 630template <class _Rp>631void __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg) {632 unique_lock<mutex> __lk(this->__mut_);633 if (this->__has_value())634 __throw_future_error(future_errc::promise_already_satisfied);635 __value_ = std::addressof(__arg);636 this->__state_ |= base::__constructed;637 __thread_local_data()->__make_ready_at_thread_exit(this);638}639 640template <class _Rp>641_Rp& __assoc_state<_Rp&>::copy() {642 unique_lock<mutex> __lk(this->__mut_);643 this->__sub_wait(__lk);644 if (this->__exception_ != nullptr)645 std::rethrow_exception(this->__exception_);646 return *__value_;647}648 649template <class _Rp, class _Alloc>650class __assoc_state_alloc : public __assoc_state<_Rp> {651 typedef __assoc_state<_Rp> base;652 _Alloc __alloc_;653 654 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;655 656public:657 _LIBCPP_HIDE_FROM_ABI explicit __assoc_state_alloc(const _Alloc& __a) : __alloc_(__a) {}658};659 660template <class _Rp, class _Alloc>661void __assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT {662 if (this->__state_ & base::__constructed)663 reinterpret_cast<_Rp*>(std::addressof(this->__value_))->~_Rp();664 typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;665 typedef allocator_traits<_Al> _ATraits;666 typedef pointer_traits<typename _ATraits::pointer> _PTraits;667 _Al __a(__alloc_);668 this->~__assoc_state_alloc();669 __a.deallocate(_PTraits::pointer_to(*this), 1);670}671 672template <class _Rp, class _Alloc>673class __assoc_state_alloc<_Rp&, _Alloc> : public __assoc_state<_Rp&> {674 typedef __assoc_state<_Rp&> base;675 _Alloc __alloc_;676 677 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;678 679public:680 _LIBCPP_HIDE_FROM_ABI explicit __assoc_state_alloc(const _Alloc& __a) : __alloc_(__a) {}681};682 683template <class _Rp, class _Alloc>684void __assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT {685 typedef typename __allocator_traits_rebind<_Alloc, __assoc_state_alloc>::type _Al;686 typedef allocator_traits<_Al> _ATraits;687 typedef pointer_traits<typename _ATraits::pointer> _PTraits;688 _Al __a(__alloc_);689 this->~__assoc_state_alloc();690 __a.deallocate(_PTraits::pointer_to(*this), 1);691}692 693template <class _Alloc>694class __assoc_sub_state_alloc : public __assoc_sub_state {695 typedef __assoc_sub_state base;696 _Alloc __alloc_;697 698 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;699 700public:701 _LIBCPP_HIDE_FROM_ABI explicit __assoc_sub_state_alloc(const _Alloc& __a) : __alloc_(__a) {}702};703 704template <class _Alloc>705void __assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT {706 typedef typename __allocator_traits_rebind<_Alloc, __assoc_sub_state_alloc>::type _Al;707 typedef allocator_traits<_Al> _ATraits;708 typedef pointer_traits<typename _ATraits::pointer> _PTraits;709 _Al __a(__alloc_);710 this->~__assoc_sub_state_alloc();711 __a.deallocate(_PTraits::pointer_to(*this), 1);712}713 714template <class _Rp, class _Fp>715class __deferred_assoc_state : public __assoc_state<_Rp> {716 typedef __assoc_state<_Rp> base;717 718 _Fp __func_;719 720public:721 _LIBCPP_HIDE_FROM_ABI explicit __deferred_assoc_state(_Fp&& __f);722 723 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute();724};725 726template <class _Rp, class _Fp>727inline __deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {728 this->__set_deferred();729}730 731template <class _Rp, class _Fp>732void __deferred_assoc_state<_Rp, _Fp>::__execute() {733# ifndef _LIBCPP_HAS_NO_EXCEPTIONS734 try {735# endif // _LIBCPP_HAS_NO_EXCEPTIONS736 this->set_value(__func_());737# ifndef _LIBCPP_HAS_NO_EXCEPTIONS738 } catch (...) {739 this->set_exception(current_exception());740 }741# endif // _LIBCPP_HAS_NO_EXCEPTIONS742}743 744template <class _Fp>745class __deferred_assoc_state<void, _Fp> : public __assoc_sub_state {746 typedef __assoc_sub_state base;747 748 _Fp __func_;749 750public:751 _LIBCPP_HIDE_FROM_ABI explicit __deferred_assoc_state(_Fp&& __f);752 753 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override;754};755 756template <class _Fp>757inline __deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {758 this->__set_deferred();759}760 761template <class _Fp>762void __deferred_assoc_state<void, _Fp>::__execute() {763# ifndef _LIBCPP_HAS_NO_EXCEPTIONS764 try {765# endif // _LIBCPP_HAS_NO_EXCEPTIONS766 __func_();767 this->set_value();768# ifndef _LIBCPP_HAS_NO_EXCEPTIONS769 } catch (...) {770 this->set_exception(current_exception());771 }772# endif // _LIBCPP_HAS_NO_EXCEPTIONS773}774 775template <class _Rp, class _Fp>776class __async_assoc_state : public __assoc_state<_Rp> {777 typedef __assoc_state<_Rp> base;778 779 _Fp __func_;780 781 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __on_zero_shared() _NOEXCEPT;782 783public:784 _LIBCPP_HIDE_FROM_ABI explicit __async_assoc_state(_Fp&& __f);785 786 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __execute();787};788 789template <class _Rp, class _Fp>790inline __async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {}791 792template <class _Rp, class _Fp>793void __async_assoc_state<_Rp, _Fp>::__execute() {794# ifndef _LIBCPP_HAS_NO_EXCEPTIONS795 try {796# endif // _LIBCPP_HAS_NO_EXCEPTIONS797 this->set_value(__func_());798# ifndef _LIBCPP_HAS_NO_EXCEPTIONS799 } catch (...) {800 this->set_exception(current_exception());801 }802# endif // _LIBCPP_HAS_NO_EXCEPTIONS803}804 805template <class _Rp, class _Fp>806void __async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT {807 this->wait();808 base::__on_zero_shared();809}810 811template <class _Fp>812class __async_assoc_state<void, _Fp> : public __assoc_sub_state {813 typedef __assoc_sub_state base;814 815 _Fp __func_;816 817 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;818 819public:820 _LIBCPP_HIDE_FROM_ABI explicit __async_assoc_state(_Fp&& __f);821 822 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __execute() override;823};824 825template <class _Fp>826inline __async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f) : __func_(std::forward<_Fp>(__f)) {}827 828template <class _Fp>829void __async_assoc_state<void, _Fp>::__execute() {830# ifndef _LIBCPP_HAS_NO_EXCEPTIONS831 try {832# endif // _LIBCPP_HAS_NO_EXCEPTIONS833 __func_();834 this->set_value();835# ifndef _LIBCPP_HAS_NO_EXCEPTIONS836 } catch (...) {837 this->set_exception(current_exception());838 }839# endif // _LIBCPP_HAS_NO_EXCEPTIONS840}841 842template <class _Fp>843void __async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT {844 this->wait();845 base::__on_zero_shared();846}847 848template <class _Rp>849class _LIBCPP_TEMPLATE_VIS promise;850template <class _Rp>851class _LIBCPP_TEMPLATE_VIS shared_future;852 853// future854 855template <class _Rp>856class _LIBCPP_TEMPLATE_VIS future;857 858template <class _Rp, class _Fp>859_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_deferred_assoc_state(_Fp&& __f);860 861template <class _Rp, class _Fp>862_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_async_assoc_state(_Fp&& __f);863 864template <class _Rp>865class _LIBCPP_TEMPLATE_VIS future {866 __assoc_state<_Rp>* __state_;867 868 explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp>* __state);869 870 template <class>871 friend class promise;872 template <class>873 friend class shared_future;874 875 template <class _R1, class _Fp>876 friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);877 template <class _R1, class _Fp>878 friend future<_R1> __make_async_assoc_state(_Fp&& __f);879 880public:881 _LIBCPP_HIDE_FROM_ABI future() _NOEXCEPT : __state_(nullptr) {}882 _LIBCPP_HIDE_FROM_ABI future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }883 future(const future&) = delete;884 future& operator=(const future&) = delete;885 _LIBCPP_HIDE_FROM_ABI future& operator=(future&& __rhs) _NOEXCEPT {886 future(std::move(__rhs)).swap(*this);887 return *this;888 }889 890 _LIBCPP_HIDE_FROM_ABI ~future();891 _LIBCPP_HIDE_FROM_ABI shared_future<_Rp> share() _NOEXCEPT;892 893 // retrieving the value894 _LIBCPP_HIDE_FROM_ABI _Rp get();895 896 _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }897 898 // functions to check state899 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }900 901 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }902 template <class _Rep, class _Period>903 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {904 return __state_->wait_for(__rel_time);905 }906 template <class _Clock, class _Duration>907 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {908 return __state_->wait_until(__abs_time);909 }910};911 912template <class _Rp>913future<_Rp>::future(__assoc_state<_Rp>* __state) : __state_(__state) {914 __state_->__attach_future();915}916 917struct __release_shared_count {918 _LIBCPP_HIDE_FROM_ABI void operator()(__shared_count* __p) { __p->__release_shared(); }919};920 921template <class _Rp>922future<_Rp>::~future() {923 if (__state_)924 __state_->__release_shared();925}926 927template <class _Rp>928_Rp future<_Rp>::get() {929 unique_ptr<__shared_count, __release_shared_count> __guard(__state_);930 __assoc_state<_Rp>* __s = __state_;931 __state_ = nullptr;932 return __s->move();933}934 935template <class _Rp>936class _LIBCPP_TEMPLATE_VIS future<_Rp&> {937 __assoc_state<_Rp&>* __state_;938 939 explicit _LIBCPP_HIDE_FROM_ABI future(__assoc_state<_Rp&>* __state);940 941 template <class>942 friend class promise;943 template <class>944 friend class shared_future;945 946 template <class _R1, class _Fp>947 friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);948 template <class _R1, class _Fp>949 friend future<_R1> __make_async_assoc_state(_Fp&& __f);950 951public:952 _LIBCPP_HIDE_FROM_ABI future() _NOEXCEPT : __state_(nullptr) {}953 _LIBCPP_HIDE_FROM_ABI future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }954 future(const future&) = delete;955 future& operator=(const future&) = delete;956 _LIBCPP_HIDE_FROM_ABI future& operator=(future&& __rhs) _NOEXCEPT {957 future(std::move(__rhs)).swap(*this);958 return *this;959 }960 961 _LIBCPP_HIDE_FROM_ABI ~future();962 _LIBCPP_HIDE_FROM_ABI shared_future<_Rp&> share() _NOEXCEPT;963 964 // retrieving the value965 _LIBCPP_HIDE_FROM_ABI _Rp& get();966 967 _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }968 969 // functions to check state970 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }971 972 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }973 template <class _Rep, class _Period>974 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {975 return __state_->wait_for(__rel_time);976 }977 template <class _Clock, class _Duration>978 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {979 return __state_->wait_until(__abs_time);980 }981};982 983template <class _Rp>984future<_Rp&>::future(__assoc_state<_Rp&>* __state) : __state_(__state) {985 __state_->__attach_future();986}987 988template <class _Rp>989future<_Rp&>::~future() {990 if (__state_)991 __state_->__release_shared();992}993 994template <class _Rp>995_Rp& future<_Rp&>::get() {996 unique_ptr<__shared_count, __release_shared_count> __guard(__state_);997 __assoc_state<_Rp&>* __s = __state_;998 __state_ = nullptr;999 return __s->copy();1000}1001 1002template <>1003class _LIBCPP_EXPORTED_FROM_ABI future<void> {1004 __assoc_sub_state* __state_;1005 1006 explicit future(__assoc_sub_state* __state);1007 1008 template <class>1009 friend class promise;1010 template <class>1011 friend class shared_future;1012 1013 template <class _R1, class _Fp>1014 friend future<_R1> __make_deferred_assoc_state(_Fp&& __f);1015 template <class _R1, class _Fp>1016 friend future<_R1> __make_async_assoc_state(_Fp&& __f);1017 1018public:1019 _LIBCPP_HIDE_FROM_ABI future() _NOEXCEPT : __state_(nullptr) {}1020 _LIBCPP_HIDE_FROM_ABI future(future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }1021 future(const future&) = delete;1022 future& operator=(const future&) = delete;1023 _LIBCPP_HIDE_FROM_ABI future& operator=(future&& __rhs) _NOEXCEPT {1024 future(std::move(__rhs)).swap(*this);1025 return *this;1026 }1027 1028 ~future();1029 _LIBCPP_HIDE_FROM_ABI shared_future<void> share() _NOEXCEPT;1030 1031 // retrieving the value1032 void get();1033 1034 _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }1035 1036 // functions to check state1037 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }1038 1039 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }1040 template <class _Rep, class _Period>1041 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {1042 return __state_->wait_for(__rel_time);1043 }1044 template <class _Clock, class _Duration>1045 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {1046 return __state_->wait_until(__abs_time);1047 }1048};1049 1050template <class _Rp>1051inline _LIBCPP_HIDE_FROM_ABI void swap(future<_Rp>& __x, future<_Rp>& __y) _NOEXCEPT {1052 __x.swap(__y);1053}1054 1055// promise<R>1056 1057template <class _Callable>1058class packaged_task;1059 1060template <class _Rp>1061class _LIBCPP_TEMPLATE_VIS promise {1062 __assoc_state<_Rp>* __state_;1063 1064 _LIBCPP_HIDE_FROM_ABI explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}1065 1066 template <class>1067 friend class packaged_task;1068 1069public:1070 _LIBCPP_HIDE_FROM_ABI promise();1071 template <class _Alloc>1072 _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Alloc& __a);1073 _LIBCPP_HIDE_FROM_ABI promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }1074 promise(const promise& __rhs) = delete;1075 _LIBCPP_HIDE_FROM_ABI ~promise();1076 1077 // assignment1078 _LIBCPP_HIDE_FROM_ABI promise& operator=(promise&& __rhs) _NOEXCEPT {1079 promise(std::move(__rhs)).swap(*this);1080 return *this;1081 }1082 promise& operator=(const promise& __rhs) = delete;1083 1084 _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }1085 1086 // retrieving the result1087 _LIBCPP_HIDE_FROM_ABI future<_Rp> get_future();1088 1089 // setting the result1090 _LIBCPP_HIDE_FROM_ABI void set_value(const _Rp& __r);1091 _LIBCPP_HIDE_FROM_ABI void set_value(_Rp&& __r);1092 _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p);1093 1094 // setting the result with deferred notification1095 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(const _Rp& __r);1096 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&& __r);1097 _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p);1098};1099 1100template <class _Rp>1101promise<_Rp>::promise() : __state_(new __assoc_state<_Rp>) {}1102 1103template <class _Rp>1104template <class _Alloc>1105promise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0) {1106 typedef __assoc_state_alloc<_Rp, _Alloc> _State;1107 typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;1108 typedef __allocator_destructor<_A2> _D2;1109 _A2 __a(__a0);1110 unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));1111 ::new ((void*)std::addressof(*__hold.get())) _State(__a0);1112 __state_ = std::addressof(*__hold.release());1113}1114 1115template <class _Rp>1116promise<_Rp>::~promise() {1117 if (__state_) {1118 if (!__state_->__has_value() && __state_->use_count() > 1)1119 __state_->set_exception(make_exception_ptr(future_error(make_error_code(future_errc::broken_promise))));1120 __state_->__release_shared();1121 }1122}1123 1124template <class _Rp>1125future<_Rp> promise<_Rp>::get_future() {1126 if (__state_ == nullptr)1127 __throw_future_error(future_errc::no_state);1128 return future<_Rp>(__state_);1129}1130 1131template <class _Rp>1132void promise<_Rp>::set_value(const _Rp& __r) {1133 if (__state_ == nullptr)1134 __throw_future_error(future_errc::no_state);1135 __state_->set_value(__r);1136}1137 1138template <class _Rp>1139void promise<_Rp>::set_value(_Rp&& __r) {1140 if (__state_ == nullptr)1141 __throw_future_error(future_errc::no_state);1142 __state_->set_value(std::move(__r));1143}1144 1145template <class _Rp>1146void promise<_Rp>::set_exception(exception_ptr __p) {1147 _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception: received nullptr");1148 if (__state_ == nullptr)1149 __throw_future_error(future_errc::no_state);1150 __state_->set_exception(__p);1151}1152 1153template <class _Rp>1154void promise<_Rp>::set_value_at_thread_exit(const _Rp& __r) {1155 if (__state_ == nullptr)1156 __throw_future_error(future_errc::no_state);1157 __state_->set_value_at_thread_exit(__r);1158}1159 1160template <class _Rp>1161void promise<_Rp>::set_value_at_thread_exit(_Rp&& __r) {1162 if (__state_ == nullptr)1163 __throw_future_error(future_errc::no_state);1164 __state_->set_value_at_thread_exit(std::move(__r));1165}1166 1167template <class _Rp>1168void promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p) {1169 _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception_at_thread_exit: received nullptr");1170 if (__state_ == nullptr)1171 __throw_future_error(future_errc::no_state);1172 __state_->set_exception_at_thread_exit(__p);1173}1174 1175// promise<R&>1176 1177template <class _Rp>1178class _LIBCPP_TEMPLATE_VIS promise<_Rp&> {1179 __assoc_state<_Rp&>* __state_;1180 1181 _LIBCPP_HIDE_FROM_ABI explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}1182 1183 template <class>1184 friend class packaged_task;1185 1186public:1187 _LIBCPP_HIDE_FROM_ABI promise();1188 template <class _Allocator>1189 _LIBCPP_HIDE_FROM_ABI promise(allocator_arg_t, const _Allocator& __a);1190 _LIBCPP_HIDE_FROM_ABI promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }1191 promise(const promise& __rhs) = delete;1192 _LIBCPP_HIDE_FROM_ABI ~promise();1193 1194 // assignment1195 _LIBCPP_HIDE_FROM_ABI promise& operator=(promise&& __rhs) _NOEXCEPT {1196 promise(std::move(__rhs)).swap(*this);1197 return *this;1198 }1199 promise& operator=(const promise& __rhs) = delete;1200 1201 _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }1202 1203 // retrieving the result1204 _LIBCPP_HIDE_FROM_ABI future<_Rp&> get_future();1205 1206 // setting the result1207 _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __r);1208 _LIBCPP_HIDE_FROM_ABI void set_exception(exception_ptr __p);1209 1210 // setting the result with deferred notification1211 _LIBCPP_HIDE_FROM_ABI void set_value_at_thread_exit(_Rp&);1212 _LIBCPP_HIDE_FROM_ABI void set_exception_at_thread_exit(exception_ptr __p);1213};1214 1215template <class _Rp>1216promise<_Rp&>::promise() : __state_(new __assoc_state<_Rp&>) {}1217 1218template <class _Rp>1219template <class _Alloc>1220promise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0) {1221 typedef __assoc_state_alloc<_Rp&, _Alloc> _State;1222 typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;1223 typedef __allocator_destructor<_A2> _D2;1224 _A2 __a(__a0);1225 unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));1226 ::new ((void*)std::addressof(*__hold.get())) _State(__a0);1227 __state_ = std::addressof(*__hold.release());1228}1229 1230template <class _Rp>1231promise<_Rp&>::~promise() {1232 if (__state_) {1233 if (!__state_->__has_value() && __state_->use_count() > 1)1234 __state_->set_exception(make_exception_ptr(future_error(make_error_code(future_errc::broken_promise))));1235 __state_->__release_shared();1236 }1237}1238 1239template <class _Rp>1240future<_Rp&> promise<_Rp&>::get_future() {1241 if (__state_ == nullptr)1242 __throw_future_error(future_errc::no_state);1243 return future<_Rp&>(__state_);1244}1245 1246template <class _Rp>1247void promise<_Rp&>::set_value(_Rp& __r) {1248 if (__state_ == nullptr)1249 __throw_future_error(future_errc::no_state);1250 __state_->set_value(__r);1251}1252 1253template <class _Rp>1254void promise<_Rp&>::set_exception(exception_ptr __p) {1255 _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception: received nullptr");1256 if (__state_ == nullptr)1257 __throw_future_error(future_errc::no_state);1258 __state_->set_exception(__p);1259}1260 1261template <class _Rp>1262void promise<_Rp&>::set_value_at_thread_exit(_Rp& __r) {1263 if (__state_ == nullptr)1264 __throw_future_error(future_errc::no_state);1265 __state_->set_value_at_thread_exit(__r);1266}1267 1268template <class _Rp>1269void promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p) {1270 _LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception_at_thread_exit: received nullptr");1271 if (__state_ == nullptr)1272 __throw_future_error(future_errc::no_state);1273 __state_->set_exception_at_thread_exit(__p);1274}1275 1276// promise<void>1277 1278template <>1279class _LIBCPP_EXPORTED_FROM_ABI promise<void> {1280 __assoc_sub_state* __state_;1281 1282 _LIBCPP_HIDE_FROM_ABI explicit promise(nullptr_t) _NOEXCEPT : __state_(nullptr) {}1283 1284 template <class>1285 friend class packaged_task;1286 1287public:1288 promise();1289 template <class _Allocator>1290 _LIBCPP_METHOD_TEMPLATE_IMPLICIT_INSTANTIATION_VIS promise(allocator_arg_t, const _Allocator& __a);1291 _LIBCPP_HIDE_FROM_ABI promise(promise&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) { __rhs.__state_ = nullptr; }1292 promise(const promise& __rhs) = delete;1293 ~promise();1294 1295 // assignment1296 _LIBCPP_HIDE_FROM_ABI promise& operator=(promise&& __rhs) _NOEXCEPT {1297 promise(std::move(__rhs)).swap(*this);1298 return *this;1299 }1300 promise& operator=(const promise& __rhs) = delete;1301 1302 _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }1303 1304 // retrieving the result1305 future<void> get_future();1306 1307 // setting the result1308 void set_value();1309 void set_exception(exception_ptr __p);1310 1311 // setting the result with deferred notification1312 void set_value_at_thread_exit();1313 void set_exception_at_thread_exit(exception_ptr __p);1314};1315 1316template <class _Alloc>1317promise<void>::promise(allocator_arg_t, const _Alloc& __a0) {1318 typedef __assoc_sub_state_alloc<_Alloc> _State;1319 typedef typename __allocator_traits_rebind<_Alloc, _State>::type _A2;1320 typedef __allocator_destructor<_A2> _D2;1321 _A2 __a(__a0);1322 unique_ptr<_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));1323 ::new ((void*)std::addressof(*__hold.get())) _State(__a0);1324 __state_ = std::addressof(*__hold.release());1325}1326 1327template <class _Rp>1328inline _LIBCPP_HIDE_FROM_ABI void swap(promise<_Rp>& __x, promise<_Rp>& __y) _NOEXCEPT {1329 __x.swap(__y);1330}1331 1332template <class _Rp, class _Alloc>1333struct _LIBCPP_TEMPLATE_VIS uses_allocator<promise<_Rp>, _Alloc> : public true_type {};1334 1335// packaged_task1336 1337template <class _Fp>1338class __packaged_task_base;1339 1340template <class _Rp, class... _ArgTypes>1341class __packaged_task_base<_Rp(_ArgTypes...)> {1342public:1343 _LIBCPP_HIDE_FROM_ABI __packaged_task_base() {}1344 __packaged_task_base(const __packaged_task_base&) = delete;1345 __packaged_task_base& operator=(const __packaged_task_base&) = delete;1346 _LIBCPP_HIDE_FROM_ABI_VIRTUAL1347 virtual ~__packaged_task_base() {}1348 virtual void __move_to(__packaged_task_base*) _NOEXCEPT = 0;1349 virtual void destroy() = 0;1350 virtual void destroy_deallocate() = 0;1351 virtual _Rp operator()(_ArgTypes&&...) = 0;1352};1353 1354template <class _FD, class _Alloc, class _FB>1355class __packaged_task_func;1356 1357template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>1358class __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)> : public __packaged_task_base<_Rp(_ArgTypes...)> {1359 __compressed_pair<_Fp, _Alloc> __f_;1360 1361public:1362 _LIBCPP_HIDE_FROM_ABI explicit __packaged_task_func(const _Fp& __f) : __f_(__f, __default_init_tag()) {}1363 _LIBCPP_HIDE_FROM_ABI explicit __packaged_task_func(_Fp&& __f) : __f_(std::move(__f), __default_init_tag()) {}1364 _LIBCPP_HIDE_FROM_ABI __packaged_task_func(const _Fp& __f, const _Alloc& __a) : __f_(__f, __a) {}1365 _LIBCPP_HIDE_FROM_ABI __packaged_task_func(_Fp&& __f, const _Alloc& __a) : __f_(std::move(__f), __a) {}1366 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*) _NOEXCEPT;1367 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy();1368 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual void destroy_deallocate();1369 _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual _Rp operator()(_ArgTypes&&... __args);1370};1371 1372template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>1373void __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to(1374 __packaged_task_base<_Rp(_ArgTypes...)>* __p) _NOEXCEPT {1375 ::new ((void*)__p) __packaged_task_func(std::move(__f_.first()), std::move(__f_.second()));1376}1377 1378template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>1379void __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() {1380 __f_.~__compressed_pair<_Fp, _Alloc>();1381}1382 1383template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>1384void __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() {1385 typedef typename __allocator_traits_rebind<_Alloc, __packaged_task_func>::type _Ap;1386 typedef allocator_traits<_Ap> _ATraits;1387 typedef pointer_traits<typename _ATraits::pointer> _PTraits;1388 _Ap __a(__f_.second());1389 __f_.~__compressed_pair<_Fp, _Alloc>();1390 __a.deallocate(_PTraits::pointer_to(*this), 1);1391}1392 1393template <class _Fp, class _Alloc, class _Rp, class... _ArgTypes>1394_Rp __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&&... __arg) {1395 return std::__invoke(__f_.first(), std::forward<_ArgTypes>(__arg)...);1396}1397 1398template <class _Callable>1399class __packaged_task_function;1400 1401template <class _Rp, class... _ArgTypes>1402class __packaged_task_function<_Rp(_ArgTypes...)> {1403 typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;1404 1405 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI __base* __get_buf() { return (__base*)&__buf_; }1406 1407 _LIBCPP_SUPPRESS_DEPRECATED_PUSH1408 typename aligned_storage<3 * sizeof(void*)>::type __buf_;1409 _LIBCPP_SUPPRESS_DEPRECATED_POP1410 __base* __f_;1411 1412public:1413 typedef _Rp result_type;1414 1415 // construct/copy/destroy:1416 _LIBCPP_HIDE_FROM_ABI __packaged_task_function() _NOEXCEPT : __f_(nullptr) {}1417 template <class _Fp>1418 _LIBCPP_HIDE_FROM_ABI __packaged_task_function(_Fp&& __f);1419 template <class _Fp, class _Alloc>1420 _LIBCPP_HIDE_FROM_ABI __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f);1421 1422 _LIBCPP_HIDE_FROM_ABI __packaged_task_function(__packaged_task_function&&) _NOEXCEPT;1423 _LIBCPP_HIDE_FROM_ABI __packaged_task_function& operator=(__packaged_task_function&&) _NOEXCEPT;1424 1425 __packaged_task_function(const __packaged_task_function&) = delete;1426 __packaged_task_function& operator=(const __packaged_task_function&) = delete;1427 1428 _LIBCPP_HIDE_FROM_ABI ~__packaged_task_function();1429 1430 _LIBCPP_HIDE_FROM_ABI void swap(__packaged_task_function&) _NOEXCEPT;1431 1432 _LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes...) const;1433};1434 1435template <class _Rp, class... _ArgTypes>1436__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) _NOEXCEPT {1437 if (__f.__f_ == nullptr)1438 __f_ = nullptr;1439 else if (__f.__f_ == __f.__get_buf()) {1440 __f.__f_->__move_to(__get_buf());1441 __f_ = (__base*)&__buf_;1442 } else {1443 __f_ = __f.__f_;1444 __f.__f_ = nullptr;1445 }1446}1447 1448template <class _Rp, class... _ArgTypes>1449template <class _Fp>1450__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f) : __f_(nullptr) {1451 typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR;1452 typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF;1453 if (sizeof(_FF) <= sizeof(__buf_)) {1454 ::new ((void*)&__buf_) _FF(std::forward<_Fp>(__f));1455 __f_ = (__base*)&__buf_;1456 } else {1457 typedef allocator<_FF> _Ap;1458 _Ap __a;1459 typedef __allocator_destructor<_Ap> _Dp;1460 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));1461 ::new ((void*)__hold.get()) _FF(std::forward<_Fp>(__f), allocator<_FR>(__a));1462 __f_ = __hold.release();1463 }1464}1465 1466template <class _Rp, class... _ArgTypes>1467template <class _Fp, class _Alloc>1468__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(allocator_arg_t, const _Alloc& __a0, _Fp&& __f)1469 : __f_(nullptr) {1470 typedef __libcpp_remove_reference_t<__decay_t<_Fp> > _FR;1471 typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF;1472 if (sizeof(_FF) <= sizeof(__buf_)) {1473 __f_ = (__base*)&__buf_;1474 ::new ((void*)__f_) _FF(std::forward<_Fp>(__f));1475 } else {1476 typedef typename __allocator_traits_rebind<_Alloc, _FF>::type _Ap;1477 _Ap __a(__a0);1478 typedef __allocator_destructor<_Ap> _Dp;1479 unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));1480 ::new ((void*)std::addressof(*__hold.get())) _FF(std::forward<_Fp>(__f), _Alloc(__a));1481 __f_ = std::addressof(*__hold.release());1482 }1483}1484 1485template <class _Rp, class... _ArgTypes>1486__packaged_task_function<_Rp(_ArgTypes...)>&1487__packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) _NOEXCEPT {1488 if (__f_ == __get_buf())1489 __f_->destroy();1490 else if (__f_)1491 __f_->destroy_deallocate();1492 __f_ = nullptr;1493 if (__f.__f_ == nullptr)1494 __f_ = nullptr;1495 else if (__f.__f_ == __f.__get_buf()) {1496 __f.__f_->__move_to(__get_buf());1497 __f_ = __get_buf();1498 } else {1499 __f_ = __f.__f_;1500 __f.__f_ = nullptr;1501 }1502 return *this;1503}1504 1505template <class _Rp, class... _ArgTypes>1506__packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function() {1507 if (__f_ == __get_buf())1508 __f_->destroy();1509 else if (__f_)1510 __f_->destroy_deallocate();1511}1512 1513template <class _Rp, class... _ArgTypes>1514_LIBCPP_NO_CFI void __packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT {1515 if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) {1516 _LIBCPP_SUPPRESS_DEPRECATED_PUSH1517 typename aligned_storage<sizeof(__buf_)>::type __tempbuf;1518 _LIBCPP_SUPPRESS_DEPRECATED_POP1519 __base* __t = (__base*)&__tempbuf;1520 __f_->__move_to(__t);1521 __f_->destroy();1522 __f_ = nullptr;1523 __f.__f_->__move_to((__base*)&__buf_);1524 __f.__f_->destroy();1525 __f.__f_ = nullptr;1526 __f_ = (__base*)&__buf_;1527 __t->__move_to((__base*)&__f.__buf_);1528 __t->destroy();1529 __f.__f_ = (__base*)&__f.__buf_;1530 } else if (__f_ == (__base*)&__buf_) {1531 __f_->__move_to((__base*)&__f.__buf_);1532 __f_->destroy();1533 __f_ = __f.__f_;1534 __f.__f_ = (__base*)&__f.__buf_;1535 } else if (__f.__f_ == (__base*)&__f.__buf_) {1536 __f.__f_->__move_to((__base*)&__buf_);1537 __f.__f_->destroy();1538 __f.__f_ = __f_;1539 __f_ = (__base*)&__buf_;1540 } else1541 std::swap(__f_, __f.__f_);1542}1543 1544template <class _Rp, class... _ArgTypes>1545inline _Rp __packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const {1546 return (*__f_)(std::forward<_ArgTypes>(__arg)...);1547}1548 1549template <class _Rp, class... _ArgTypes>1550class _LIBCPP_TEMPLATE_VIS packaged_task<_Rp(_ArgTypes...)> {1551public:1552 typedef _Rp result_type; // extension1553 1554private:1555 __packaged_task_function<result_type(_ArgTypes...)> __f_;1556 promise<result_type> __p_;1557 1558public:1559 // construction and destruction1560 _LIBCPP_HIDE_FROM_ABI packaged_task() _NOEXCEPT : __p_(nullptr) {}1561 1562 template <class _Fp, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0>1563 _LIBCPP_HIDE_FROM_ABI explicit packaged_task(_Fp&& __f) : __f_(std::forward<_Fp>(__f)) {}1564 1565 template <class _Fp, class _Allocator, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0>1566 _LIBCPP_HIDE_FROM_ABI packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)1567 : __f_(allocator_arg_t(), __a, std::forward<_Fp>(__f)), __p_(allocator_arg_t(), __a) {}1568 // ~packaged_task() = default;1569 1570 // no copy1571 packaged_task(const packaged_task&) = delete;1572 packaged_task& operator=(const packaged_task&) = delete;1573 1574 // move support1575 _LIBCPP_HIDE_FROM_ABI packaged_task(packaged_task&& __other) _NOEXCEPT1576 : __f_(std::move(__other.__f_)),1577 __p_(std::move(__other.__p_)) {}1578 _LIBCPP_HIDE_FROM_ABI packaged_task& operator=(packaged_task&& __other) _NOEXCEPT {1579 __f_ = std::move(__other.__f_);1580 __p_ = std::move(__other.__p_);1581 return *this;1582 }1583 _LIBCPP_HIDE_FROM_ABI void swap(packaged_task& __other) _NOEXCEPT {1584 __f_.swap(__other.__f_);1585 __p_.swap(__other.__p_);1586 }1587 1588 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; }1589 1590 // result retrieval1591 _LIBCPP_HIDE_FROM_ABI future<result_type> get_future() { return __p_.get_future(); }1592 1593 // execution1594 _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);1595 _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args);1596 1597 _LIBCPP_HIDE_FROM_ABI void reset();1598};1599 1600template <class _Rp, class... _ArgTypes>1601void packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args) {1602 if (__p_.__state_ == nullptr)1603 __throw_future_error(future_errc::no_state);1604 if (__p_.__state_->__has_value())1605 __throw_future_error(future_errc::promise_already_satisfied);1606# ifndef _LIBCPP_HAS_NO_EXCEPTIONS1607 try {1608# endif // _LIBCPP_HAS_NO_EXCEPTIONS1609 __p_.set_value(__f_(std::forward<_ArgTypes>(__args)...));1610# ifndef _LIBCPP_HAS_NO_EXCEPTIONS1611 } catch (...) {1612 __p_.set_exception(current_exception());1613 }1614# endif // _LIBCPP_HAS_NO_EXCEPTIONS1615}1616 1617template <class _Rp, class... _ArgTypes>1618void packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) {1619 if (__p_.__state_ == nullptr)1620 __throw_future_error(future_errc::no_state);1621 if (__p_.__state_->__has_value())1622 __throw_future_error(future_errc::promise_already_satisfied);1623# ifndef _LIBCPP_HAS_NO_EXCEPTIONS1624 try {1625# endif // _LIBCPP_HAS_NO_EXCEPTIONS1626 __p_.set_value_at_thread_exit(__f_(std::forward<_ArgTypes>(__args)...));1627# ifndef _LIBCPP_HAS_NO_EXCEPTIONS1628 } catch (...) {1629 __p_.set_exception_at_thread_exit(current_exception());1630 }1631# endif // _LIBCPP_HAS_NO_EXCEPTIONS1632}1633 1634template <class _Rp, class... _ArgTypes>1635void packaged_task<_Rp(_ArgTypes...)>::reset() {1636 if (!valid())1637 __throw_future_error(future_errc::no_state);1638 __p_ = promise<result_type>();1639}1640 1641template <class... _ArgTypes>1642class _LIBCPP_TEMPLATE_VIS packaged_task<void(_ArgTypes...)> {1643public:1644 typedef void result_type; // extension1645 1646private:1647 __packaged_task_function<result_type(_ArgTypes...)> __f_;1648 promise<result_type> __p_;1649 1650public:1651 // construction and destruction1652 _LIBCPP_HIDE_FROM_ABI packaged_task() _NOEXCEPT : __p_(nullptr) {}1653 template <class _Fp, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0>1654 _LIBCPP_HIDE_FROM_ABI explicit packaged_task(_Fp&& __f) : __f_(std::forward<_Fp>(__f)) {}1655 template <class _Fp, class _Allocator, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, packaged_task>::value, int> = 0>1656 _LIBCPP_HIDE_FROM_ABI packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f)1657 : __f_(allocator_arg_t(), __a, std::forward<_Fp>(__f)), __p_(allocator_arg_t(), __a) {}1658 // ~packaged_task() = default;1659 1660 // no copy1661 packaged_task(const packaged_task&) = delete;1662 packaged_task& operator=(const packaged_task&) = delete;1663 1664 // move support1665 _LIBCPP_HIDE_FROM_ABI packaged_task(packaged_task&& __other) _NOEXCEPT1666 : __f_(std::move(__other.__f_)),1667 __p_(std::move(__other.__p_)) {}1668 _LIBCPP_HIDE_FROM_ABI packaged_task& operator=(packaged_task&& __other) _NOEXCEPT {1669 __f_ = std::move(__other.__f_);1670 __p_ = std::move(__other.__p_);1671 return *this;1672 }1673 _LIBCPP_HIDE_FROM_ABI void swap(packaged_task& __other) _NOEXCEPT {1674 __f_.swap(__other.__f_);1675 __p_.swap(__other.__p_);1676 }1677 1678 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; }1679 1680 // result retrieval1681 _LIBCPP_HIDE_FROM_ABI future<result_type> get_future() { return __p_.get_future(); }1682 1683 // execution1684 _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);1685 _LIBCPP_HIDE_FROM_ABI void make_ready_at_thread_exit(_ArgTypes... __args);1686 1687 _LIBCPP_HIDE_FROM_ABI void reset();1688};1689 1690template <class... _ArgTypes>1691void packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args) {1692 if (__p_.__state_ == nullptr)1693 __throw_future_error(future_errc::no_state);1694 if (__p_.__state_->__has_value())1695 __throw_future_error(future_errc::promise_already_satisfied);1696# ifndef _LIBCPP_HAS_NO_EXCEPTIONS1697 try {1698# endif // _LIBCPP_HAS_NO_EXCEPTIONS1699 __f_(std::forward<_ArgTypes>(__args)...);1700 __p_.set_value();1701# ifndef _LIBCPP_HAS_NO_EXCEPTIONS1702 } catch (...) {1703 __p_.set_exception(current_exception());1704 }1705# endif // _LIBCPP_HAS_NO_EXCEPTIONS1706}1707 1708template <class... _ArgTypes>1709void packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) {1710 if (__p_.__state_ == nullptr)1711 __throw_future_error(future_errc::no_state);1712 if (__p_.__state_->__has_value())1713 __throw_future_error(future_errc::promise_already_satisfied);1714# ifndef _LIBCPP_HAS_NO_EXCEPTIONS1715 try {1716# endif // _LIBCPP_HAS_NO_EXCEPTIONS1717 __f_(std::forward<_ArgTypes>(__args)...);1718 __p_.set_value_at_thread_exit();1719# ifndef _LIBCPP_HAS_NO_EXCEPTIONS1720 } catch (...) {1721 __p_.set_exception_at_thread_exit(current_exception());1722 }1723# endif // _LIBCPP_HAS_NO_EXCEPTIONS1724}1725 1726template <class... _ArgTypes>1727void packaged_task<void(_ArgTypes...)>::reset() {1728 if (!valid())1729 __throw_future_error(future_errc::no_state);1730 __p_ = promise<result_type>();1731}1732 1733template <class _Rp, class... _ArgTypes>1734inline _LIBCPP_HIDE_FROM_ABI void1735swap(packaged_task<_Rp(_ArgTypes...)>& __x, packaged_task<_Rp(_ArgTypes...)>& __y) _NOEXCEPT {1736 __x.swap(__y);1737}1738 1739template <class _Callable, class _Alloc>1740struct _LIBCPP_TEMPLATE_VIS uses_allocator<packaged_task<_Callable>, _Alloc> : public true_type {};1741 1742template <class _Rp, class _Fp>1743_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_deferred_assoc_state(_Fp&& __f) {1744 unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count> __h(1745 new __deferred_assoc_state<_Rp, _Fp>(std::forward<_Fp>(__f)));1746 return future<_Rp>(__h.get());1747}1748 1749template <class _Rp, class _Fp>1750_LIBCPP_HIDE_FROM_ABI future<_Rp> __make_async_assoc_state(_Fp&& __f) {1751 unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count> __h(1752 new __async_assoc_state<_Rp, _Fp>(std::forward<_Fp>(__f)));1753 std::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();1754 return future<_Rp>(__h.get());1755}1756 1757// shared_future1758 1759template <class _Rp>1760class _LIBCPP_TEMPLATE_VIS shared_future {1761 __assoc_state<_Rp>* __state_;1762 1763public:1764 _LIBCPP_HIDE_FROM_ABI shared_future() _NOEXCEPT : __state_(nullptr) {}1765 _LIBCPP_HIDE_FROM_ABI shared_future(const shared_future& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {1766 if (__state_)1767 __state_->__add_shared();1768 }1769 _LIBCPP_HIDE_FROM_ABI shared_future(future<_Rp>&& __f) _NOEXCEPT : __state_(__f.__state_) { __f.__state_ = nullptr; }1770 _LIBCPP_HIDE_FROM_ABI shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {1771 __rhs.__state_ = nullptr;1772 }1773 _LIBCPP_HIDE_FROM_ABI ~shared_future();1774 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs) _NOEXCEPT;1775 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(shared_future&& __rhs) _NOEXCEPT {1776 shared_future(std::move(__rhs)).swap(*this);1777 return *this;1778 }1779 1780 // retrieving the value1781 _LIBCPP_HIDE_FROM_ABI const _Rp& get() const { return __state_->copy(); }1782 1783 _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }1784 1785 // functions to check state1786 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }1787 1788 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }1789 template <class _Rep, class _Period>1790 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {1791 return __state_->wait_for(__rel_time);1792 }1793 template <class _Clock, class _Duration>1794 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {1795 return __state_->wait_until(__abs_time);1796 }1797};1798 1799template <class _Rp>1800shared_future<_Rp>::~shared_future() {1801 if (__state_)1802 __state_->__release_shared();1803}1804 1805template <class _Rp>1806shared_future<_Rp>& shared_future<_Rp>::operator=(const shared_future& __rhs) _NOEXCEPT {1807 if (__rhs.__state_)1808 __rhs.__state_->__add_shared();1809 if (__state_)1810 __state_->__release_shared();1811 __state_ = __rhs.__state_;1812 return *this;1813}1814 1815template <class _Rp>1816class _LIBCPP_TEMPLATE_VIS shared_future<_Rp&> {1817 __assoc_state<_Rp&>* __state_;1818 1819public:1820 _LIBCPP_HIDE_FROM_ABI shared_future() _NOEXCEPT : __state_(nullptr) {}1821 _LIBCPP_HIDE_FROM_ABI shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) {1822 if (__state_)1823 __state_->__add_shared();1824 }1825 _LIBCPP_HIDE_FROM_ABI shared_future(future<_Rp&>&& __f) _NOEXCEPT : __state_(__f.__state_) { __f.__state_ = nullptr; }1826 _LIBCPP_HIDE_FROM_ABI shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {1827 __rhs.__state_ = nullptr;1828 }1829 _LIBCPP_HIDE_FROM_ABI ~shared_future();1830 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(const shared_future& __rhs);1831 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(shared_future&& __rhs) _NOEXCEPT {1832 shared_future(std::move(__rhs)).swap(*this);1833 return *this;1834 }1835 1836 // retrieving the value1837 _LIBCPP_HIDE_FROM_ABI _Rp& get() const { return __state_->copy(); }1838 1839 _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }1840 1841 // functions to check state1842 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }1843 1844 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }1845 template <class _Rep, class _Period>1846 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {1847 return __state_->wait_for(__rel_time);1848 }1849 template <class _Clock, class _Duration>1850 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {1851 return __state_->wait_until(__abs_time);1852 }1853};1854 1855template <class _Rp>1856shared_future<_Rp&>::~shared_future() {1857 if (__state_)1858 __state_->__release_shared();1859}1860 1861template <class _Rp>1862shared_future<_Rp&>& shared_future<_Rp&>::operator=(const shared_future& __rhs) {1863 if (__rhs.__state_)1864 __rhs.__state_->__add_shared();1865 if (__state_)1866 __state_->__release_shared();1867 __state_ = __rhs.__state_;1868 return *this;1869}1870 1871template <>1872class _LIBCPP_EXPORTED_FROM_ABI shared_future<void> {1873 __assoc_sub_state* __state_;1874 1875public:1876 _LIBCPP_HIDE_FROM_ABI shared_future() _NOEXCEPT : __state_(nullptr) {}1877 _LIBCPP_HIDE_FROM_ABI shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) {1878 if (__state_)1879 __state_->__add_shared();1880 }1881 _LIBCPP_HIDE_FROM_ABI shared_future(future<void>&& __f) _NOEXCEPT : __state_(__f.__state_) { __f.__state_ = nullptr; }1882 _LIBCPP_HIDE_FROM_ABI shared_future(shared_future&& __rhs) _NOEXCEPT : __state_(__rhs.__state_) {1883 __rhs.__state_ = nullptr;1884 }1885 ~shared_future();1886 shared_future& operator=(const shared_future& __rhs);1887 _LIBCPP_HIDE_FROM_ABI shared_future& operator=(shared_future&& __rhs) _NOEXCEPT {1888 shared_future(std::move(__rhs)).swap(*this);1889 return *this;1890 }1891 1892 // retrieving the value1893 _LIBCPP_HIDE_FROM_ABI void get() const { __state_->copy(); }1894 1895 _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }1896 1897 // functions to check state1898 _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }1899 1900 _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }1901 template <class _Rep, class _Period>1902 _LIBCPP_HIDE_FROM_ABI future_status wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const {1903 return __state_->wait_for(__rel_time);1904 }1905 template <class _Clock, class _Duration>1906 _LIBCPP_HIDE_FROM_ABI future_status wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const {1907 return __state_->wait_until(__abs_time);1908 }1909};1910 1911template <class _Rp>1912inline _LIBCPP_HIDE_FROM_ABI void swap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) _NOEXCEPT {1913 __x.swap(__y);1914}1915 1916template <class _Rp>1917inline shared_future<_Rp> future<_Rp>::share() _NOEXCEPT {1918 return shared_future<_Rp>(std::move(*this));1919}1920 1921template <class _Rp>1922inline shared_future<_Rp&> future<_Rp&>::share() _NOEXCEPT {1923 return shared_future<_Rp&>(std::move(*this));1924}1925 1926inline shared_future<void> future<void>::share() _NOEXCEPT { return shared_future<void>(std::move(*this)); }1927 1928_LIBCPP_END_NAMESPACE_STD1929 1930_LIBCPP_POP_MACROS1931 1932#endif // !defined(_LIBCPP_HAS_NO_THREADS)1933 1934#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES)1935# include <__cxx03/chrono>1936#endif1937 1938#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES)1939# include <__cxx03/atomic>1940# include <__cxx03/cstdlib>1941# include <__cxx03/exception>1942# include <__cxx03/iosfwd>1943# include <__cxx03/system_error>1944#endif1945 1946#endif // _LIBCPP___CXX03_FUTURE1947