future revision 232950
1227825Stheraven// -*- C++ -*- 2227825Stheraven//===--------------------------- future -----------------------------------===// 3227825Stheraven// 4227825Stheraven// The LLVM Compiler Infrastructure 5227825Stheraven// 6227825Stheraven// This file is dual licensed under the MIT and the University of Illinois Open 7227825Stheraven// Source Licenses. See LICENSE.TXT for details. 8227825Stheraven// 9227825Stheraven//===----------------------------------------------------------------------===// 10227825Stheraven 11227825Stheraven#ifndef _LIBCPP_FUTURE 12227825Stheraven#define _LIBCPP_FUTURE 13227825Stheraven 14227825Stheraven/* 15227825Stheraven future synopsis 16227825Stheraven 17227825Stheravennamespace std 18227825Stheraven{ 19227825Stheraven 20227825Stheravenenum class future_errc 21227825Stheraven{ 22227825Stheraven broken_promise, 23227825Stheraven future_already_retrieved, 24227825Stheraven promise_already_satisfied, 25227825Stheraven no_state 26227825Stheraven}; 27227825Stheraven 28227825Stheravenenum class launch 29227825Stheraven{ 30227825Stheraven async = 1, 31227825Stheraven deferred = 2, 32227825Stheraven any = async | deferred 33227825Stheraven}; 34227825Stheraven 35227825Stheravenenum class future_status 36227825Stheraven{ 37227825Stheraven ready, 38227825Stheraven timeout, 39227825Stheraven deferred 40227825Stheraven}; 41227825Stheraven 42227825Stheraventemplate <> struct is_error_code_enum<future_errc> : public true_type { }; 43227825Stheravenerror_code make_error_code(future_errc e); 44227825Stheravenerror_condition make_error_condition(future_errc e); 45227825Stheraven 46227825Stheravenconst error_category& future_category(); 47227825Stheraven 48227825Stheravenclass future_error 49227825Stheraven : public logic_error 50227825Stheraven{ 51227825Stheravenpublic: 52227825Stheraven future_error(error_code ec); // exposition only 53227825Stheraven 54227825Stheraven const error_code& code() const throw(); 55227825Stheraven const char* what() const throw(); 56227825Stheraven}; 57227825Stheraven 58227825Stheraventemplate <class R> 59227825Stheravenclass promise 60227825Stheraven{ 61227825Stheravenpublic: 62227825Stheraven promise(); 63227825Stheraven template <class Allocator> 64227825Stheraven promise(allocator_arg_t, const Allocator& a); 65227825Stheraven promise(promise&& rhs); 66227825Stheraven promise(const promise& rhs) = delete; 67227825Stheraven ~promise(); 68227825Stheraven 69227825Stheraven // assignment 70227825Stheraven promise& operator=(promise&& rhs); 71227825Stheraven promise& operator=(const promise& rhs) = delete; 72227825Stheraven void swap(promise& other); 73227825Stheraven 74227825Stheraven // retrieving the result 75227825Stheraven future<R> get_future(); 76227825Stheraven 77227825Stheraven // setting the result 78227825Stheraven void set_value(const R& r); 79227825Stheraven void set_value(R&& r); 80227825Stheraven void set_exception(exception_ptr p); 81227825Stheraven 82227825Stheraven // setting the result with deferred notification 83227825Stheraven void set_value_at_thread_exit(const R& r); 84227825Stheraven void set_value_at_thread_exit(R&& r); 85227825Stheraven void set_exception_at_thread_exit(exception_ptr p); 86227825Stheraven}; 87227825Stheraven 88227825Stheraventemplate <class R> 89227825Stheravenclass promise<R&> 90227825Stheraven{ 91227825Stheravenpublic: 92227825Stheraven promise(); 93227825Stheraven template <class Allocator> 94227825Stheraven promise(allocator_arg_t, const Allocator& a); 95227825Stheraven promise(promise&& rhs); 96227825Stheraven promise(const promise& rhs) = delete; 97227825Stheraven ~promise(); 98227825Stheraven 99227825Stheraven // assignment 100227825Stheraven promise& operator=(promise&& rhs); 101227825Stheraven promise& operator=(const promise& rhs) = delete; 102227825Stheraven void swap(promise& other); 103227825Stheraven 104227825Stheraven // retrieving the result 105227825Stheraven future<R&> get_future(); 106227825Stheraven 107227825Stheraven // setting the result 108227825Stheraven void set_value(R& r); 109227825Stheraven void set_exception(exception_ptr p); 110227825Stheraven 111227825Stheraven // setting the result with deferred notification 112227825Stheraven void set_value_at_thread_exit(R&); 113227825Stheraven void set_exception_at_thread_exit(exception_ptr p); 114227825Stheraven}; 115227825Stheraven 116227825Stheraventemplate <> 117227825Stheravenclass promise<void> 118227825Stheraven{ 119227825Stheravenpublic: 120227825Stheraven promise(); 121227825Stheraven template <class Allocator> 122227825Stheraven promise(allocator_arg_t, const Allocator& a); 123227825Stheraven promise(promise&& rhs); 124227825Stheraven promise(const promise& rhs) = delete; 125227825Stheraven ~promise(); 126227825Stheraven 127227825Stheraven // assignment 128227825Stheraven promise& operator=(promise&& rhs); 129227825Stheraven promise& operator=(const promise& rhs) = delete; 130227825Stheraven void swap(promise& other); 131227825Stheraven 132227825Stheraven // retrieving the result 133227825Stheraven future<void> get_future(); 134227825Stheraven 135227825Stheraven // setting the result 136227825Stheraven void set_value(); 137227825Stheraven void set_exception(exception_ptr p); 138227825Stheraven 139227825Stheraven // setting the result with deferred notification 140227825Stheraven void set_value_at_thread_exit(); 141227825Stheraven void set_exception_at_thread_exit(exception_ptr p); 142227825Stheraven}; 143227825Stheraven 144227825Stheraventemplate <class R> void swap(promise<R>& x, promise<R>& y); 145227825Stheraven 146227825Stheraventemplate <class R, class Alloc> 147227825Stheraven struct uses_allocator<promise<R>, Alloc> : public true_type {}; 148227825Stheraven 149227825Stheraventemplate <class R> 150227825Stheravenclass future 151227825Stheraven{ 152227825Stheravenpublic: 153227825Stheraven future(); 154227825Stheraven future(future&&); 155227825Stheraven future(const future& rhs) = delete; 156227825Stheraven ~future(); 157227825Stheraven future& operator=(const future& rhs) = delete; 158227825Stheraven future& operator=(future&&); 159227825Stheraven shared_future<R> share() &&; 160227825Stheraven 161227825Stheraven // retrieving the value 162227825Stheraven R get(); 163227825Stheraven 164227825Stheraven // functions to check state 165227825Stheraven bool valid() const; 166227825Stheraven 167227825Stheraven void wait() const; 168227825Stheraven template <class Rep, class Period> 169227825Stheraven future_status 170227825Stheraven wait_for(const chrono::duration<Rep, Period>& rel_time) const; 171227825Stheraven template <class Clock, class Duration> 172227825Stheraven future_status 173227825Stheraven wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; 174227825Stheraven}; 175227825Stheraven 176227825Stheraventemplate <class R> 177227825Stheravenclass future<R&> 178227825Stheraven{ 179227825Stheravenpublic: 180227825Stheraven future(); 181227825Stheraven future(future&&); 182227825Stheraven future(const future& rhs) = delete; 183227825Stheraven ~future(); 184227825Stheraven future& operator=(const future& rhs) = delete; 185227825Stheraven future& operator=(future&&); 186227825Stheraven shared_future<R&> share() &&; 187227825Stheraven 188227825Stheraven // retrieving the value 189227825Stheraven R& get(); 190227825Stheraven 191227825Stheraven // functions to check state 192227825Stheraven bool valid() const; 193227825Stheraven 194227825Stheraven void wait() const; 195227825Stheraven template <class Rep, class Period> 196227825Stheraven future_status 197227825Stheraven wait_for(const chrono::duration<Rep, Period>& rel_time) const; 198227825Stheraven template <class Clock, class Duration> 199227825Stheraven future_status 200227825Stheraven wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; 201227825Stheraven}; 202227825Stheraven 203227825Stheraventemplate <> 204227825Stheravenclass future<void> 205227825Stheraven{ 206227825Stheravenpublic: 207227825Stheraven future(); 208227825Stheraven future(future&&); 209227825Stheraven future(const future& rhs) = delete; 210227825Stheraven ~future(); 211227825Stheraven future& operator=(const future& rhs) = delete; 212227825Stheraven future& operator=(future&&); 213227825Stheraven shared_future<void> share() &&; 214227825Stheraven 215227825Stheraven // retrieving the value 216227825Stheraven void get(); 217227825Stheraven 218227825Stheraven // functions to check state 219227825Stheraven bool valid() const; 220227825Stheraven 221227825Stheraven void wait() const; 222227825Stheraven template <class Rep, class Period> 223227825Stheraven future_status 224227825Stheraven wait_for(const chrono::duration<Rep, Period>& rel_time) const; 225227825Stheraven template <class Clock, class Duration> 226227825Stheraven future_status 227227825Stheraven wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; 228227825Stheraven}; 229227825Stheraven 230227825Stheraventemplate <class R> 231227825Stheravenclass shared_future 232227825Stheraven{ 233227825Stheravenpublic: 234227825Stheraven shared_future(); 235227825Stheraven shared_future(const shared_future& rhs); 236227825Stheraven shared_future(future<R>&&); 237227825Stheraven shared_future(shared_future&& rhs); 238227825Stheraven ~shared_future(); 239227825Stheraven shared_future& operator=(const shared_future& rhs); 240227825Stheraven shared_future& operator=(shared_future&& rhs); 241227825Stheraven 242227825Stheraven // retrieving the value 243227825Stheraven const R& get() const; 244227825Stheraven 245227825Stheraven // functions to check state 246227825Stheraven bool valid() const; 247227825Stheraven 248227825Stheraven void wait() const; 249227825Stheraven template <class Rep, class Period> 250227825Stheraven future_status 251227825Stheraven wait_for(const chrono::duration<Rep, Period>& rel_time) const; 252227825Stheraven template <class Clock, class Duration> 253227825Stheraven future_status 254227825Stheraven wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; 255227825Stheraven}; 256227825Stheraven 257227825Stheraventemplate <class R> 258227825Stheravenclass shared_future<R&> 259227825Stheraven{ 260227825Stheravenpublic: 261227825Stheraven shared_future(); 262227825Stheraven shared_future(const shared_future& rhs); 263227825Stheraven shared_future(future<R&>&&); 264227825Stheraven shared_future(shared_future&& rhs); 265227825Stheraven ~shared_future(); 266227825Stheraven shared_future& operator=(const shared_future& rhs); 267227825Stheraven shared_future& operator=(shared_future&& rhs); 268227825Stheraven 269227825Stheraven // retrieving the value 270227825Stheraven R& get() const; 271227825Stheraven 272227825Stheraven // functions to check state 273227825Stheraven bool valid() const; 274227825Stheraven 275227825Stheraven void wait() const; 276227825Stheraven template <class Rep, class Period> 277227825Stheraven future_status 278227825Stheraven wait_for(const chrono::duration<Rep, Period>& rel_time) const; 279227825Stheraven template <class Clock, class Duration> 280227825Stheraven future_status 281227825Stheraven wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; 282227825Stheraven}; 283227825Stheraven 284227825Stheraventemplate <> 285227825Stheravenclass shared_future<void> 286227825Stheraven{ 287227825Stheravenpublic: 288227825Stheraven shared_future(); 289227825Stheraven shared_future(const shared_future& rhs); 290227825Stheraven shared_future(future<void>&&); 291227825Stheraven shared_future(shared_future&& rhs); 292227825Stheraven ~shared_future(); 293227825Stheraven shared_future& operator=(const shared_future& rhs); 294227825Stheraven shared_future& operator=(shared_future&& rhs); 295227825Stheraven 296227825Stheraven // retrieving the value 297227825Stheraven void get() const; 298227825Stheraven 299227825Stheraven // functions to check state 300227825Stheraven bool valid() const; 301227825Stheraven 302227825Stheraven void wait() const; 303227825Stheraven template <class Rep, class Period> 304227825Stheraven future_status 305227825Stheraven wait_for(const chrono::duration<Rep, Period>& rel_time) const; 306227825Stheraven template <class Clock, class Duration> 307227825Stheraven future_status 308227825Stheraven wait_until(const chrono::time_point<Clock, Duration>& abs_time) const; 309227825Stheraven}; 310227825Stheraven 311227825Stheraventemplate <class F, class... Args> 312227825Stheraven future<typename result_of<F(Args...)>::type> 313227825Stheraven async(F&& f, Args&&... args); 314227825Stheraven 315227825Stheraventemplate <class F, class... Args> 316227825Stheraven future<typename result_of<F(Args...)>::type> 317227825Stheraven async(launch policy, F&& f, Args&&... args); 318227825Stheraven 319227825Stheraventemplate <class> class packaged_task; // undefined 320227825Stheraven 321227825Stheraventemplate <class R, class... ArgTypes> 322227825Stheravenclass packaged_task<R(ArgTypes...)> 323227825Stheraven{ 324227825Stheravenpublic: 325227825Stheraven typedef R result_type; 326227825Stheraven 327227825Stheraven // construction and destruction 328227825Stheraven packaged_task(); 329227825Stheraven template <class F> 330227825Stheraven explicit packaged_task(F&& f); 331227825Stheraven template <class F, class Allocator> 332227825Stheraven explicit packaged_task(allocator_arg_t, const Allocator& a, F&& f); 333227825Stheraven ~packaged_task(); 334227825Stheraven 335227825Stheraven // no copy 336227825Stheraven packaged_task(packaged_task&) = delete; 337227825Stheraven packaged_task& operator=(packaged_task&) = delete; 338227825Stheraven 339227825Stheraven // move support 340227825Stheraven packaged_task(packaged_task&& other); 341227825Stheraven packaged_task& operator=(packaged_task&& other); 342227825Stheraven void swap(packaged_task& other); 343227825Stheraven 344227825Stheraven bool valid() const; 345227825Stheraven 346227825Stheraven // result retrieval 347227825Stheraven future<R> get_future(); 348227825Stheraven 349227825Stheraven // execution 350227825Stheraven void operator()(ArgTypes... ); 351227825Stheraven void make_ready_at_thread_exit(ArgTypes...); 352227825Stheraven 353227825Stheraven void reset(); 354227825Stheraven}; 355227825Stheraven 356227825Stheraventemplate <class R> 357227825Stheraven void swap(packaged_task<R(ArgTypes...)&, packaged_task<R(ArgTypes...)>&); 358227825Stheraven 359227825Stheraventemplate <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>; 360227825Stheraven 361227825Stheraven} // std 362227825Stheraven 363227825Stheraven*/ 364227825Stheraven 365227825Stheraven#include <__config> 366227825Stheraven#include <system_error> 367227825Stheraven#include <memory> 368227825Stheraven#include <chrono> 369227825Stheraven#include <exception> 370227825Stheraven#include <mutex> 371227825Stheraven#include <thread> 372227825Stheraven 373227825Stheraven#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 374227825Stheraven#pragma GCC system_header 375227825Stheraven#endif 376227825Stheraven 377227825Stheraven_LIBCPP_BEGIN_NAMESPACE_STD 378227825Stheraven 379227825Stheraven//enum class future_errc 380232950Stheraven_LIBCPP_DECLARE_STRONG_ENUM(future_errc) 381227825Stheraven{ 382227825Stheraven broken_promise, 383227825Stheraven future_already_retrieved, 384227825Stheraven promise_already_satisfied, 385227825Stheraven no_state 386227825Stheraven}; 387232950Stheraven_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_errc) 388227825Stheraven 389227825Stheraventemplate <> 390227825Stheravenstruct _LIBCPP_VISIBLE is_error_code_enum<future_errc> : public true_type {}; 391227825Stheraven 392232950Stheraven#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS 393232950Stheraventemplate <> 394232950Stheravenstruct _LIBCPP_VISIBLE is_error_code_enum<future_errc::_> : public true_type { }; 395232950Stheraven#endif 396232950Stheraven 397227825Stheraven//enum class launch 398232950Stheraven_LIBCPP_DECLARE_STRONG_ENUM(launch) 399227825Stheraven{ 400227825Stheraven async = 1, 401227825Stheraven deferred = 2, 402227825Stheraven any = async | deferred 403227825Stheraven}; 404232950Stheraven_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(launch) 405227825Stheraven 406227825Stheraven//enum class future_status 407232950Stheraven_LIBCPP_DECLARE_STRONG_ENUM(future_status) 408227825Stheraven{ 409227825Stheraven ready, 410227825Stheraven timeout, 411227825Stheraven deferred 412227825Stheraven}; 413232950Stheraven_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status) 414227825Stheraven 415227825Stheraven_LIBCPP_VISIBLE 416227825Stheravenconst error_category& future_category(); 417227825Stheraven 418227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 419227825Stheravenerror_code 420227825Stheravenmake_error_code(future_errc __e) 421227825Stheraven{ 422227825Stheraven return error_code(static_cast<int>(__e), future_category()); 423227825Stheraven} 424227825Stheraven 425227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 426227825Stheravenerror_condition 427227825Stheravenmake_error_condition(future_errc __e) 428227825Stheraven{ 429227825Stheraven return error_condition(static_cast<int>(__e), future_category()); 430227825Stheraven} 431227825Stheraven 432227825Stheravenclass _LIBCPP_EXCEPTION_ABI future_error 433227825Stheraven : public logic_error 434227825Stheraven{ 435227825Stheraven error_code __ec_; 436227825Stheravenpublic: 437227825Stheraven future_error(error_code __ec); 438227825Stheraven 439227825Stheraven _LIBCPP_INLINE_VISIBILITY 440227825Stheraven const error_code& code() const throw() {return __ec_;} 441227825Stheraven 442227825Stheraven virtual ~future_error() _NOEXCEPT; 443227825Stheraven}; 444227825Stheraven 445227825Stheravenclass __assoc_sub_state 446227825Stheraven : public __shared_count 447227825Stheraven{ 448227825Stheravenprotected: 449227825Stheraven exception_ptr __exception_; 450227825Stheraven mutable mutex __mut_; 451227825Stheraven mutable condition_variable __cv_; 452227825Stheraven unsigned __state_; 453227825Stheraven 454227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 455227825Stheraven void __sub_wait(unique_lock<mutex>& __lk); 456227825Stheravenpublic: 457227825Stheraven enum 458227825Stheraven { 459227825Stheraven __constructed = 1, 460227825Stheraven __future_attached = 2, 461227825Stheraven ready = 4, 462227825Stheraven deferred = 8 463227825Stheraven }; 464227825Stheraven 465227825Stheraven _LIBCPP_INLINE_VISIBILITY 466227825Stheraven __assoc_sub_state() : __state_(0) {} 467227825Stheraven 468227825Stheraven _LIBCPP_INLINE_VISIBILITY 469227825Stheraven bool __has_value() const 470227825Stheraven {return (__state_ & __constructed) || (__exception_ != nullptr);} 471227825Stheraven 472227825Stheraven _LIBCPP_INLINE_VISIBILITY 473227825Stheraven void __set_future_attached() {__state_ |= __future_attached;} 474227825Stheraven _LIBCPP_INLINE_VISIBILITY 475227825Stheraven bool __has_future_attached() const {return __state_ & __future_attached;} 476227825Stheraven 477227825Stheraven _LIBCPP_INLINE_VISIBILITY 478227825Stheraven void __set_deferred() {__state_ |= deferred;} 479227825Stheraven 480227825Stheraven void __make_ready(); 481227825Stheraven _LIBCPP_INLINE_VISIBILITY 482227825Stheraven bool __is_ready() const {return __state_ & ready;} 483227825Stheraven 484227825Stheraven void set_value(); 485227825Stheraven void set_value_at_thread_exit(); 486227825Stheraven 487227825Stheraven void set_exception(exception_ptr __p); 488227825Stheraven void set_exception_at_thread_exit(exception_ptr __p); 489227825Stheraven 490227825Stheraven void copy(); 491227825Stheraven 492227825Stheraven void wait(); 493227825Stheraven template <class _Rep, class _Period> 494227825Stheraven future_status 495227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const; 496227825Stheraven template <class _Clock, class _Duration> 497227825Stheraven future_status 498227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const; 499227825Stheraven 500227825Stheraven virtual void __execute(); 501227825Stheraven}; 502227825Stheraven 503227825Stheraventemplate <class _Clock, class _Duration> 504227825Stheravenfuture_status 505227825Stheraven__assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 506227825Stheraven{ 507227825Stheraven unique_lock<mutex> __lk(__mut_); 508227825Stheraven if (__state_ & deferred) 509227825Stheraven return future_status::deferred; 510227825Stheraven while (!(__state_ & ready) && _Clock::now() < __abs_time) 511227825Stheraven __cv_.wait_until(__lk, __abs_time); 512227825Stheraven if (__state_ & ready) 513227825Stheraven return future_status::ready; 514227825Stheraven return future_status::timeout; 515227825Stheraven} 516227825Stheraven 517227825Stheraventemplate <class _Rep, class _Period> 518227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 519227825Stheravenfuture_status 520227825Stheraven__assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 521227825Stheraven{ 522227825Stheraven return wait_until(chrono::steady_clock::now() + __rel_time); 523227825Stheraven} 524227825Stheraven 525232950Stheraventemplate <class _Rp> 526227825Stheravenclass __assoc_state 527227825Stheraven : public __assoc_sub_state 528227825Stheraven{ 529227825Stheraven typedef __assoc_sub_state base; 530232950Stheraven typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up; 531227825Stheravenprotected: 532232950Stheraven _Up __value_; 533227825Stheraven 534227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 535227825Stheravenpublic: 536227825Stheraven 537227825Stheraven template <class _Arg> 538227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 539227825Stheraven void set_value(_Arg&& __arg); 540227825Stheraven#else 541227825Stheraven void set_value(_Arg& __arg); 542227825Stheraven#endif 543227825Stheraven 544227825Stheraven template <class _Arg> 545227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 546227825Stheraven void set_value_at_thread_exit(_Arg&& __arg); 547227825Stheraven#else 548227825Stheraven void set_value_at_thread_exit(_Arg& __arg); 549227825Stheraven#endif 550227825Stheraven 551232950Stheraven _Rp move(); 552232950Stheraven typename add_lvalue_reference<_Rp>::type copy(); 553227825Stheraven}; 554227825Stheraven 555232950Stheraventemplate <class _Rp> 556227825Stheravenvoid 557232950Stheraven__assoc_state<_Rp>::__on_zero_shared() _NOEXCEPT 558227825Stheraven{ 559227825Stheraven if (this->__state_ & base::__constructed) 560232950Stheraven reinterpret_cast<_Rp*>(&__value_)->~_Rp(); 561227825Stheraven delete this; 562227825Stheraven} 563227825Stheraven 564232950Stheraventemplate <class _Rp> 565227825Stheraventemplate <class _Arg> 566227825Stheravenvoid 567227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 568232950Stheraven__assoc_state<_Rp>::set_value(_Arg&& __arg) 569227825Stheraven#else 570232950Stheraven__assoc_state<_Rp>::set_value(_Arg& __arg) 571227825Stheraven#endif 572227825Stheraven{ 573227825Stheraven unique_lock<mutex> __lk(this->__mut_); 574227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 575227825Stheraven if (this->__has_value()) 576227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 577227825Stheraven#endif 578232950Stheraven ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); 579227825Stheraven this->__state_ |= base::__constructed | base::ready; 580227825Stheraven __lk.unlock(); 581227825Stheraven __cv_.notify_all(); 582227825Stheraven} 583227825Stheraven 584232950Stheraventemplate <class _Rp> 585227825Stheraventemplate <class _Arg> 586227825Stheravenvoid 587227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 588232950Stheraven__assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg) 589227825Stheraven#else 590232950Stheraven__assoc_state<_Rp>::set_value_at_thread_exit(_Arg& __arg) 591227825Stheraven#endif 592227825Stheraven{ 593227825Stheraven unique_lock<mutex> __lk(this->__mut_); 594227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 595227825Stheraven if (this->__has_value()) 596227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 597227825Stheraven#endif 598232950Stheraven ::new(&__value_) _Rp(_VSTD::forward<_Arg>(__arg)); 599227825Stheraven this->__state_ |= base::__constructed; 600227825Stheraven __thread_local_data()->__make_ready_at_thread_exit(this); 601227825Stheraven __lk.unlock(); 602227825Stheraven} 603227825Stheraven 604232950Stheraventemplate <class _Rp> 605232950Stheraven_Rp 606232950Stheraven__assoc_state<_Rp>::move() 607227825Stheraven{ 608227825Stheraven unique_lock<mutex> __lk(this->__mut_); 609227825Stheraven this->__sub_wait(__lk); 610227825Stheraven if (this->__exception_ != nullptr) 611227825Stheraven rethrow_exception(this->__exception_); 612232950Stheraven return _VSTD::move(*reinterpret_cast<_Rp*>(&__value_)); 613227825Stheraven} 614227825Stheraven 615232950Stheraventemplate <class _Rp> 616232950Stheraventypename add_lvalue_reference<_Rp>::type 617232950Stheraven__assoc_state<_Rp>::copy() 618227825Stheraven{ 619227825Stheraven unique_lock<mutex> __lk(this->__mut_); 620227825Stheraven this->__sub_wait(__lk); 621227825Stheraven if (this->__exception_ != nullptr) 622227825Stheraven rethrow_exception(this->__exception_); 623232950Stheraven return *reinterpret_cast<_Rp*>(&__value_); 624227825Stheraven} 625227825Stheraven 626232950Stheraventemplate <class _Rp> 627232950Stheravenclass __assoc_state<_Rp&> 628227825Stheraven : public __assoc_sub_state 629227825Stheraven{ 630227825Stheraven typedef __assoc_sub_state base; 631232950Stheraven typedef _Rp* _Up; 632227825Stheravenprotected: 633232950Stheraven _Up __value_; 634227825Stheraven 635227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 636227825Stheravenpublic: 637227825Stheraven 638232950Stheraven void set_value(_Rp& __arg); 639232950Stheraven void set_value_at_thread_exit(_Rp& __arg); 640227825Stheraven 641232950Stheraven _Rp& copy(); 642227825Stheraven}; 643227825Stheraven 644232950Stheraventemplate <class _Rp> 645227825Stheravenvoid 646232950Stheraven__assoc_state<_Rp&>::__on_zero_shared() _NOEXCEPT 647227825Stheraven{ 648227825Stheraven delete this; 649227825Stheraven} 650227825Stheraven 651232950Stheraventemplate <class _Rp> 652227825Stheravenvoid 653232950Stheraven__assoc_state<_Rp&>::set_value(_Rp& __arg) 654227825Stheraven{ 655227825Stheraven unique_lock<mutex> __lk(this->__mut_); 656227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 657227825Stheraven if (this->__has_value()) 658227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 659227825Stheraven#endif 660227825Stheraven __value_ = &__arg; 661227825Stheraven this->__state_ |= base::__constructed | base::ready; 662227825Stheraven __lk.unlock(); 663227825Stheraven __cv_.notify_all(); 664227825Stheraven} 665227825Stheraven 666232950Stheraventemplate <class _Rp> 667227825Stheravenvoid 668232950Stheraven__assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg) 669227825Stheraven{ 670227825Stheraven unique_lock<mutex> __lk(this->__mut_); 671227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 672227825Stheraven if (this->__has_value()) 673227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 674227825Stheraven#endif 675227825Stheraven __value_ = &__arg; 676227825Stheraven this->__state_ |= base::__constructed; 677227825Stheraven __thread_local_data()->__make_ready_at_thread_exit(this); 678227825Stheraven __lk.unlock(); 679227825Stheraven} 680227825Stheraven 681232950Stheraventemplate <class _Rp> 682232950Stheraven_Rp& 683232950Stheraven__assoc_state<_Rp&>::copy() 684227825Stheraven{ 685227825Stheraven unique_lock<mutex> __lk(this->__mut_); 686227825Stheraven this->__sub_wait(__lk); 687227825Stheraven if (this->__exception_ != nullptr) 688227825Stheraven rethrow_exception(this->__exception_); 689227825Stheraven return *__value_; 690227825Stheraven} 691227825Stheraven 692232950Stheraventemplate <class _Rp, class _Alloc> 693227825Stheravenclass __assoc_state_alloc 694232950Stheraven : public __assoc_state<_Rp> 695227825Stheraven{ 696232950Stheraven typedef __assoc_state<_Rp> base; 697227825Stheraven _Alloc __alloc_; 698227825Stheraven 699227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 700227825Stheravenpublic: 701227825Stheraven _LIBCPP_INLINE_VISIBILITY 702227825Stheraven explicit __assoc_state_alloc(const _Alloc& __a) 703227825Stheraven : __alloc_(__a) {} 704227825Stheraven}; 705227825Stheraven 706232950Stheraventemplate <class _Rp, class _Alloc> 707227825Stheravenvoid 708232950Stheraven__assoc_state_alloc<_Rp, _Alloc>::__on_zero_shared() _NOEXCEPT 709227825Stheraven{ 710227825Stheraven if (this->__state_ & base::__constructed) 711232950Stheraven reinterpret_cast<_Rp*>(&this->__value_)->~_Rp(); 712227825Stheraven typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_); 713227825Stheraven this->~__assoc_state_alloc(); 714227825Stheraven __a.deallocate(this, 1); 715227825Stheraven} 716227825Stheraven 717232950Stheraventemplate <class _Rp, class _Alloc> 718232950Stheravenclass __assoc_state_alloc<_Rp&, _Alloc> 719232950Stheraven : public __assoc_state<_Rp&> 720227825Stheraven{ 721232950Stheraven typedef __assoc_state<_Rp&> base; 722227825Stheraven _Alloc __alloc_; 723227825Stheraven 724227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 725227825Stheravenpublic: 726227825Stheraven _LIBCPP_INLINE_VISIBILITY 727227825Stheraven explicit __assoc_state_alloc(const _Alloc& __a) 728227825Stheraven : __alloc_(__a) {} 729227825Stheraven}; 730227825Stheraven 731232950Stheraventemplate <class _Rp, class _Alloc> 732227825Stheravenvoid 733232950Stheraven__assoc_state_alloc<_Rp&, _Alloc>::__on_zero_shared() _NOEXCEPT 734227825Stheraven{ 735227825Stheraven typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_); 736227825Stheraven this->~__assoc_state_alloc(); 737227825Stheraven __a.deallocate(this, 1); 738227825Stheraven} 739227825Stheraven 740227825Stheraventemplate <class _Alloc> 741227825Stheravenclass __assoc_sub_state_alloc 742227825Stheraven : public __assoc_sub_state 743227825Stheraven{ 744227825Stheraven typedef __assoc_sub_state base; 745227825Stheraven _Alloc __alloc_; 746227825Stheraven 747227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 748227825Stheravenpublic: 749227825Stheraven _LIBCPP_INLINE_VISIBILITY 750227825Stheraven explicit __assoc_sub_state_alloc(const _Alloc& __a) 751227825Stheraven : __alloc_(__a) {} 752227825Stheraven}; 753227825Stheraven 754227825Stheraventemplate <class _Alloc> 755227825Stheravenvoid 756227825Stheraven__assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT 757227825Stheraven{ 758227825Stheraven this->~base(); 759227825Stheraven typename _Alloc::template rebind<__assoc_sub_state_alloc>::other __a(__alloc_); 760227825Stheraven this->~__assoc_sub_state_alloc(); 761227825Stheraven __a.deallocate(this, 1); 762227825Stheraven} 763227825Stheraven 764232950Stheraventemplate <class _Rp, class _Fp> 765227825Stheravenclass __deferred_assoc_state 766232950Stheraven : public __assoc_state<_Rp> 767227825Stheraven{ 768232950Stheraven typedef __assoc_state<_Rp> base; 769227825Stheraven 770232950Stheraven _Fp __func_; 771227825Stheraven 772227825Stheravenpublic: 773227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 774232950Stheraven explicit __deferred_assoc_state(_Fp&& __f); 775227825Stheraven#endif 776227825Stheraven 777227825Stheraven virtual void __execute(); 778227825Stheraven}; 779227825Stheraven 780227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 781227825Stheraven 782232950Stheraventemplate <class _Rp, class _Fp> 783227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 784232950Stheraven__deferred_assoc_state<_Rp, _Fp>::__deferred_assoc_state(_Fp&& __f) 785232950Stheraven : __func_(_VSTD::forward<_Fp>(__f)) 786227825Stheraven{ 787227825Stheraven this->__set_deferred(); 788227825Stheraven} 789227825Stheraven 790227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 791227825Stheraven 792232950Stheraventemplate <class _Rp, class _Fp> 793227825Stheravenvoid 794232950Stheraven__deferred_assoc_state<_Rp, _Fp>::__execute() 795227825Stheraven{ 796227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 797227825Stheraven try 798227825Stheraven { 799227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 800227825Stheraven this->set_value(__func_()); 801227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 802227825Stheraven } 803227825Stheraven catch (...) 804227825Stheraven { 805227825Stheraven this->set_exception(current_exception()); 806227825Stheraven } 807227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 808227825Stheraven} 809227825Stheraven 810232950Stheraventemplate <class _Fp> 811232950Stheravenclass __deferred_assoc_state<void, _Fp> 812227825Stheraven : public __assoc_sub_state 813227825Stheraven{ 814227825Stheraven typedef __assoc_sub_state base; 815227825Stheraven 816232950Stheraven _Fp __func_; 817227825Stheraven 818227825Stheravenpublic: 819227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 820232950Stheraven explicit __deferred_assoc_state(_Fp&& __f); 821227825Stheraven#endif 822227825Stheraven 823227825Stheraven virtual void __execute(); 824227825Stheraven}; 825227825Stheraven 826227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 827227825Stheraven 828232950Stheraventemplate <class _Fp> 829227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 830232950Stheraven__deferred_assoc_state<void, _Fp>::__deferred_assoc_state(_Fp&& __f) 831232950Stheraven : __func_(_VSTD::forward<_Fp>(__f)) 832227825Stheraven{ 833227825Stheraven this->__set_deferred(); 834227825Stheraven} 835227825Stheraven 836227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 837227825Stheraven 838232950Stheraventemplate <class _Fp> 839227825Stheravenvoid 840232950Stheraven__deferred_assoc_state<void, _Fp>::__execute() 841227825Stheraven{ 842227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 843227825Stheraven try 844227825Stheraven { 845227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 846227825Stheraven __func_(); 847227825Stheraven this->set_value(); 848227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 849227825Stheraven } 850227825Stheraven catch (...) 851227825Stheraven { 852227825Stheraven this->set_exception(current_exception()); 853227825Stheraven } 854227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 855227825Stheraven} 856227825Stheraven 857232950Stheraventemplate <class _Rp, class _Fp> 858227825Stheravenclass __async_assoc_state 859232950Stheraven : public __assoc_state<_Rp> 860227825Stheraven{ 861232950Stheraven typedef __assoc_state<_Rp> base; 862227825Stheraven 863232950Stheraven _Fp __func_; 864227825Stheraven 865227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 866227825Stheravenpublic: 867227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 868232950Stheraven explicit __async_assoc_state(_Fp&& __f); 869227825Stheraven#endif 870227825Stheraven 871227825Stheraven virtual void __execute(); 872227825Stheraven}; 873227825Stheraven 874227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 875227825Stheraven 876232950Stheraventemplate <class _Rp, class _Fp> 877227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 878232950Stheraven__async_assoc_state<_Rp, _Fp>::__async_assoc_state(_Fp&& __f) 879232950Stheraven : __func_(_VSTD::forward<_Fp>(__f)) 880227825Stheraven{ 881227825Stheraven} 882227825Stheraven 883227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 884227825Stheraven 885232950Stheraventemplate <class _Rp, class _Fp> 886227825Stheravenvoid 887232950Stheraven__async_assoc_state<_Rp, _Fp>::__execute() 888227825Stheraven{ 889227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 890227825Stheraven try 891227825Stheraven { 892227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 893227825Stheraven this->set_value(__func_()); 894227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 895227825Stheraven } 896227825Stheraven catch (...) 897227825Stheraven { 898227825Stheraven this->set_exception(current_exception()); 899227825Stheraven } 900227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 901227825Stheraven} 902227825Stheraven 903232950Stheraventemplate <class _Rp, class _Fp> 904227825Stheravenvoid 905232950Stheraven__async_assoc_state<_Rp, _Fp>::__on_zero_shared() _NOEXCEPT 906227825Stheraven{ 907227825Stheraven this->wait(); 908227825Stheraven base::__on_zero_shared(); 909227825Stheraven} 910227825Stheraven 911232950Stheraventemplate <class _Fp> 912232950Stheravenclass __async_assoc_state<void, _Fp> 913227825Stheraven : public __assoc_sub_state 914227825Stheraven{ 915227825Stheraven typedef __assoc_sub_state base; 916227825Stheraven 917232950Stheraven _Fp __func_; 918227825Stheraven 919227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 920227825Stheravenpublic: 921227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 922232950Stheraven explicit __async_assoc_state(_Fp&& __f); 923227825Stheraven#endif 924227825Stheraven 925227825Stheraven virtual void __execute(); 926227825Stheraven}; 927227825Stheraven 928227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 929227825Stheraven 930232950Stheraventemplate <class _Fp> 931227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 932232950Stheraven__async_assoc_state<void, _Fp>::__async_assoc_state(_Fp&& __f) 933232950Stheraven : __func_(_VSTD::forward<_Fp>(__f)) 934227825Stheraven{ 935227825Stheraven} 936227825Stheraven 937227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 938227825Stheraven 939232950Stheraventemplate <class _Fp> 940227825Stheravenvoid 941232950Stheraven__async_assoc_state<void, _Fp>::__execute() 942227825Stheraven{ 943227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 944227825Stheraven try 945227825Stheraven { 946227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 947227825Stheraven __func_(); 948227825Stheraven this->set_value(); 949227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 950227825Stheraven } 951227825Stheraven catch (...) 952227825Stheraven { 953227825Stheraven this->set_exception(current_exception()); 954227825Stheraven } 955227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 956227825Stheraven} 957227825Stheraven 958232950Stheraventemplate <class _Fp> 959227825Stheravenvoid 960232950Stheraven__async_assoc_state<void, _Fp>::__on_zero_shared() _NOEXCEPT 961227825Stheraven{ 962227825Stheraven this->wait(); 963227825Stheraven base::__on_zero_shared(); 964227825Stheraven} 965227825Stheraven 966232950Stheraventemplate <class _Rp> class promise; 967232950Stheraventemplate <class _Rp> class shared_future; 968227825Stheraven 969227825Stheraven// future 970227825Stheraven 971232950Stheraventemplate <class _Rp> class future; 972227825Stheraven 973232950Stheraventemplate <class _Rp, class _Fp> 974232950Stheravenfuture<_Rp> 975227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 976232950Stheraven__make_deferred_assoc_state(_Fp&& __f); 977227825Stheraven#else 978232950Stheraven__make_deferred_assoc_state(_Fp __f); 979227825Stheraven#endif 980227825Stheraven 981232950Stheraventemplate <class _Rp, class _Fp> 982232950Stheravenfuture<_Rp> 983227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 984232950Stheraven__make_async_assoc_state(_Fp&& __f); 985227825Stheraven#else 986232950Stheraven__make_async_assoc_state(_Fp __f); 987227825Stheraven#endif 988227825Stheraven 989232950Stheraventemplate <class _Rp> 990227825Stheravenclass _LIBCPP_VISIBLE future 991227825Stheraven{ 992232950Stheraven __assoc_state<_Rp>* __state_; 993227825Stheraven 994232950Stheraven explicit future(__assoc_state<_Rp>* __state); 995227825Stheraven 996227825Stheraven template <class> friend class promise; 997227825Stheraven template <class> friend class shared_future; 998227825Stheraven 999227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1000232950Stheraven template <class _R1, class _Fp> 1001232950Stheraven friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); 1002232950Stheraven template <class _R1, class _Fp> 1003232950Stheraven friend future<_R1> __make_async_assoc_state(_Fp&& __f); 1004227825Stheraven#else 1005232950Stheraven template <class _R1, class _Fp> 1006232950Stheraven friend future<_R1> __make_deferred_assoc_state(_Fp __f); 1007232950Stheraven template <class _R1, class _Fp> 1008232950Stheraven friend future<_R1> __make_async_assoc_state(_Fp __f); 1009227825Stheraven#endif 1010227825Stheraven 1011227825Stheravenpublic: 1012227825Stheraven _LIBCPP_INLINE_VISIBILITY 1013227825Stheraven future() : __state_(nullptr) {} 1014227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1015227825Stheraven _LIBCPP_INLINE_VISIBILITY 1016227825Stheraven future(future&& __rhs) 1017227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1018227825Stheraven future(const future&) = delete; 1019227825Stheraven future& operator=(const future&) = delete; 1020227825Stheraven _LIBCPP_INLINE_VISIBILITY 1021227825Stheraven future& operator=(future&& __rhs) 1022227825Stheraven { 1023227825Stheraven future(std::move(__rhs)).swap(*this); 1024227825Stheraven return *this; 1025227825Stheraven } 1026227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1027227825Stheravenprivate: 1028227825Stheraven future(const future&); 1029227825Stheraven future& operator=(const future&); 1030227825Stheravenpublic: 1031227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1032227825Stheraven ~future(); 1033232950Stheraven shared_future<_Rp> share(); 1034227825Stheraven 1035227825Stheraven // retrieving the value 1036232950Stheraven _Rp get(); 1037227825Stheraven 1038227825Stheraven _LIBCPP_INLINE_VISIBILITY 1039227825Stheraven void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1040227825Stheraven 1041227825Stheraven // functions to check state 1042227825Stheraven _LIBCPP_INLINE_VISIBILITY 1043227825Stheraven bool valid() const {return __state_ != nullptr;} 1044227825Stheraven 1045227825Stheraven _LIBCPP_INLINE_VISIBILITY 1046227825Stheraven void wait() const {__state_->wait();} 1047227825Stheraven template <class _Rep, class _Period> 1048227825Stheraven _LIBCPP_INLINE_VISIBILITY 1049227825Stheraven future_status 1050227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 1051227825Stheraven {return __state_->wait_for(__rel_time);} 1052227825Stheraven template <class _Clock, class _Duration> 1053227825Stheraven _LIBCPP_INLINE_VISIBILITY 1054227825Stheraven future_status 1055227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 1056227825Stheraven {return __state_->wait_until(__abs_time);} 1057227825Stheraven}; 1058227825Stheraven 1059232950Stheraventemplate <class _Rp> 1060232950Stheravenfuture<_Rp>::future(__assoc_state<_Rp>* __state) 1061227825Stheraven : __state_(__state) 1062227825Stheraven{ 1063227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1064227825Stheraven if (__state_->__has_future_attached()) 1065227825Stheraven throw future_error(make_error_code(future_errc::future_already_retrieved)); 1066227825Stheraven#endif 1067227825Stheraven __state_->__add_shared(); 1068227825Stheraven __state_->__set_future_attached(); 1069227825Stheraven} 1070227825Stheraven 1071227825Stheravenstruct __release_shared_count 1072227825Stheraven{ 1073227825Stheraven void operator()(__shared_count* p) {p->__release_shared();} 1074227825Stheraven}; 1075227825Stheraven 1076232950Stheraventemplate <class _Rp> 1077232950Stheravenfuture<_Rp>::~future() 1078227825Stheraven{ 1079227825Stheraven if (__state_) 1080227825Stheraven __state_->__release_shared(); 1081227825Stheraven} 1082227825Stheraven 1083232950Stheraventemplate <class _Rp> 1084232950Stheraven_Rp 1085232950Stheravenfuture<_Rp>::get() 1086227825Stheraven{ 1087227825Stheraven unique_ptr<__shared_count, __release_shared_count> __(__state_); 1088232950Stheraven __assoc_state<_Rp>* __s = __state_; 1089227825Stheraven __state_ = nullptr; 1090227825Stheraven return __s->move(); 1091227825Stheraven} 1092227825Stheraven 1093232950Stheraventemplate <class _Rp> 1094232950Stheravenclass _LIBCPP_VISIBLE future<_Rp&> 1095227825Stheraven{ 1096232950Stheraven __assoc_state<_Rp&>* __state_; 1097227825Stheraven 1098232950Stheraven explicit future(__assoc_state<_Rp&>* __state); 1099227825Stheraven 1100227825Stheraven template <class> friend class promise; 1101227825Stheraven template <class> friend class shared_future; 1102227825Stheraven 1103227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1104232950Stheraven template <class _R1, class _Fp> 1105232950Stheraven friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); 1106232950Stheraven template <class _R1, class _Fp> 1107232950Stheraven friend future<_R1> __make_async_assoc_state(_Fp&& __f); 1108227825Stheraven#else 1109232950Stheraven template <class _R1, class _Fp> 1110232950Stheraven friend future<_R1> __make_deferred_assoc_state(_Fp __f); 1111232950Stheraven template <class _R1, class _Fp> 1112232950Stheraven friend future<_R1> __make_async_assoc_state(_Fp __f); 1113227825Stheraven#endif 1114227825Stheraven 1115227825Stheravenpublic: 1116227825Stheraven _LIBCPP_INLINE_VISIBILITY 1117227825Stheraven future() : __state_(nullptr) {} 1118227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1119227825Stheraven _LIBCPP_INLINE_VISIBILITY 1120227825Stheraven future(future&& __rhs) 1121227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1122227825Stheraven future(const future&) = delete; 1123227825Stheraven future& operator=(const future&) = delete; 1124227825Stheraven _LIBCPP_INLINE_VISIBILITY 1125227825Stheraven future& operator=(future&& __rhs) 1126227825Stheraven { 1127227825Stheraven future(std::move(__rhs)).swap(*this); 1128227825Stheraven return *this; 1129227825Stheraven } 1130227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1131227825Stheravenprivate: 1132227825Stheraven future(const future&); 1133227825Stheraven future& operator=(const future&); 1134227825Stheravenpublic: 1135227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1136227825Stheraven ~future(); 1137232950Stheraven shared_future<_Rp&> share(); 1138227825Stheraven 1139227825Stheraven // retrieving the value 1140232950Stheraven _Rp& get(); 1141227825Stheraven 1142227825Stheraven _LIBCPP_INLINE_VISIBILITY 1143227825Stheraven void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1144227825Stheraven 1145227825Stheraven // functions to check state 1146227825Stheraven _LIBCPP_INLINE_VISIBILITY 1147227825Stheraven bool valid() const {return __state_ != nullptr;} 1148227825Stheraven 1149227825Stheraven _LIBCPP_INLINE_VISIBILITY 1150227825Stheraven void wait() const {__state_->wait();} 1151227825Stheraven template <class _Rep, class _Period> 1152227825Stheraven _LIBCPP_INLINE_VISIBILITY 1153227825Stheraven future_status 1154227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 1155227825Stheraven {return __state_->wait_for(__rel_time);} 1156227825Stheraven template <class _Clock, class _Duration> 1157227825Stheraven _LIBCPP_INLINE_VISIBILITY 1158227825Stheraven future_status 1159227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 1160227825Stheraven {return __state_->wait_until(__abs_time);} 1161227825Stheraven}; 1162227825Stheraven 1163232950Stheraventemplate <class _Rp> 1164232950Stheravenfuture<_Rp&>::future(__assoc_state<_Rp&>* __state) 1165227825Stheraven : __state_(__state) 1166227825Stheraven{ 1167227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1168227825Stheraven if (__state_->__has_future_attached()) 1169227825Stheraven throw future_error(make_error_code(future_errc::future_already_retrieved)); 1170227825Stheraven#endif 1171227825Stheraven __state_->__add_shared(); 1172227825Stheraven __state_->__set_future_attached(); 1173227825Stheraven} 1174227825Stheraven 1175232950Stheraventemplate <class _Rp> 1176232950Stheravenfuture<_Rp&>::~future() 1177227825Stheraven{ 1178227825Stheraven if (__state_) 1179227825Stheraven __state_->__release_shared(); 1180227825Stheraven} 1181227825Stheraven 1182232950Stheraventemplate <class _Rp> 1183232950Stheraven_Rp& 1184232950Stheravenfuture<_Rp&>::get() 1185227825Stheraven{ 1186227825Stheraven unique_ptr<__shared_count, __release_shared_count> __(__state_); 1187232950Stheraven __assoc_state<_Rp&>* __s = __state_; 1188227825Stheraven __state_ = nullptr; 1189227825Stheraven return __s->copy(); 1190227825Stheraven} 1191227825Stheraven 1192227825Stheraventemplate <> 1193227825Stheravenclass _LIBCPP_VISIBLE future<void> 1194227825Stheraven{ 1195227825Stheraven __assoc_sub_state* __state_; 1196227825Stheraven 1197227825Stheraven explicit future(__assoc_sub_state* __state); 1198227825Stheraven 1199227825Stheraven template <class> friend class promise; 1200227825Stheraven template <class> friend class shared_future; 1201227825Stheraven 1202227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1203232950Stheraven template <class _R1, class _Fp> 1204232950Stheraven friend future<_R1> __make_deferred_assoc_state(_Fp&& __f); 1205232950Stheraven template <class _R1, class _Fp> 1206232950Stheraven friend future<_R1> __make_async_assoc_state(_Fp&& __f); 1207227825Stheraven#else 1208232950Stheraven template <class _R1, class _Fp> 1209232950Stheraven friend future<_R1> __make_deferred_assoc_state(_Fp __f); 1210232950Stheraven template <class _R1, class _Fp> 1211232950Stheraven friend future<_R1> __make_async_assoc_state(_Fp __f); 1212227825Stheraven#endif 1213227825Stheraven 1214227825Stheravenpublic: 1215227825Stheraven _LIBCPP_INLINE_VISIBILITY 1216227825Stheraven future() : __state_(nullptr) {} 1217227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1218227825Stheraven _LIBCPP_INLINE_VISIBILITY 1219227825Stheraven future(future&& __rhs) 1220227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1221227825Stheraven future(const future&) = delete; 1222227825Stheraven future& operator=(const future&) = delete; 1223227825Stheraven _LIBCPP_INLINE_VISIBILITY 1224227825Stheraven future& operator=(future&& __rhs) 1225227825Stheraven { 1226227825Stheraven future(std::move(__rhs)).swap(*this); 1227227825Stheraven return *this; 1228227825Stheraven } 1229227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1230227825Stheravenprivate: 1231227825Stheraven future(const future&); 1232227825Stheraven future& operator=(const future&); 1233227825Stheravenpublic: 1234227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1235227825Stheraven ~future(); 1236227825Stheraven shared_future<void> share(); 1237227825Stheraven 1238227825Stheraven // retrieving the value 1239227825Stheraven void get(); 1240227825Stheraven 1241227825Stheraven _LIBCPP_INLINE_VISIBILITY 1242227825Stheraven void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1243227825Stheraven 1244227825Stheraven // functions to check state 1245227825Stheraven _LIBCPP_INLINE_VISIBILITY 1246227825Stheraven bool valid() const {return __state_ != nullptr;} 1247227825Stheraven 1248227825Stheraven _LIBCPP_INLINE_VISIBILITY 1249227825Stheraven void wait() const {__state_->wait();} 1250227825Stheraven template <class _Rep, class _Period> 1251227825Stheraven _LIBCPP_INLINE_VISIBILITY 1252227825Stheraven future_status 1253227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 1254227825Stheraven {return __state_->wait_for(__rel_time);} 1255227825Stheraven template <class _Clock, class _Duration> 1256227825Stheraven _LIBCPP_INLINE_VISIBILITY 1257227825Stheraven future_status 1258227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 1259227825Stheraven {return __state_->wait_until(__abs_time);} 1260227825Stheraven}; 1261227825Stheraven 1262232950Stheraventemplate <class _Rp> 1263227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1264227825Stheravenvoid 1265232950Stheravenswap(future<_Rp>& __x, future<_Rp>& __y) 1266227825Stheraven{ 1267227825Stheraven __x.swap(__y); 1268227825Stheraven} 1269227825Stheraven 1270227825Stheraven// promise<R> 1271227825Stheraven 1272227825Stheraventemplate <class _Callable> class packaged_task; 1273227825Stheraven 1274232950Stheraventemplate <class _Rp> 1275227825Stheravenclass _LIBCPP_VISIBLE promise 1276227825Stheraven{ 1277232950Stheraven __assoc_state<_Rp>* __state_; 1278227825Stheraven 1279227825Stheraven _LIBCPP_INLINE_VISIBILITY 1280227825Stheraven explicit promise(nullptr_t) : __state_(nullptr) {} 1281227825Stheraven 1282227825Stheraven template <class> friend class packaged_task; 1283227825Stheravenpublic: 1284227825Stheraven promise(); 1285227825Stheraven template <class _Alloc> 1286227825Stheraven promise(allocator_arg_t, const _Alloc& __a); 1287227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1288227825Stheraven _LIBCPP_INLINE_VISIBILITY 1289227825Stheraven promise(promise&& __rhs) 1290227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1291227825Stheraven promise(const promise& __rhs) = delete; 1292227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1293227825Stheravenprivate: 1294227825Stheraven promise(const promise& __rhs); 1295227825Stheravenpublic: 1296227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1297227825Stheraven ~promise(); 1298227825Stheraven 1299227825Stheraven // assignment 1300227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1301227825Stheraven _LIBCPP_INLINE_VISIBILITY 1302227825Stheraven promise& operator=(promise&& __rhs) 1303227825Stheraven { 1304227825Stheraven promise(std::move(__rhs)).swap(*this); 1305227825Stheraven return *this; 1306227825Stheraven } 1307227825Stheraven promise& operator=(const promise& __rhs) = delete; 1308227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1309227825Stheravenprivate: 1310227825Stheraven promise& operator=(const promise& __rhs); 1311227825Stheravenpublic: 1312227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1313227825Stheraven _LIBCPP_INLINE_VISIBILITY 1314227825Stheraven void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1315227825Stheraven 1316227825Stheraven // retrieving the result 1317232950Stheraven future<_Rp> get_future(); 1318227825Stheraven 1319227825Stheraven // setting the result 1320232950Stheraven void set_value(const _Rp& __r); 1321227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1322232950Stheraven void set_value(_Rp&& __r); 1323227825Stheraven#endif 1324227825Stheraven void set_exception(exception_ptr __p); 1325227825Stheraven 1326227825Stheraven // setting the result with deferred notification 1327232950Stheraven void set_value_at_thread_exit(const _Rp& __r); 1328227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1329232950Stheraven void set_value_at_thread_exit(_Rp&& __r); 1330227825Stheraven#endif 1331227825Stheraven void set_exception_at_thread_exit(exception_ptr __p); 1332227825Stheraven}; 1333227825Stheraven 1334232950Stheraventemplate <class _Rp> 1335232950Stheravenpromise<_Rp>::promise() 1336232950Stheraven : __state_(new __assoc_state<_Rp>) 1337227825Stheraven{ 1338227825Stheraven} 1339227825Stheraven 1340232950Stheraventemplate <class _Rp> 1341227825Stheraventemplate <class _Alloc> 1342232950Stheravenpromise<_Rp>::promise(allocator_arg_t, const _Alloc& __a0) 1343227825Stheraven{ 1344232950Stheraven typedef typename _Alloc::template rebind<__assoc_state_alloc<_Rp, _Alloc> >::other _A2; 1345227825Stheraven typedef __allocator_destructor<_A2> _D2; 1346227825Stheraven _A2 __a(__a0); 1347232950Stheraven unique_ptr<__assoc_state_alloc<_Rp, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1)); 1348232950Stheraven ::new(__hold.get()) __assoc_state_alloc<_Rp, _Alloc>(__a0); 1349227825Stheraven __state_ = __hold.release(); 1350227825Stheraven} 1351227825Stheraven 1352232950Stheraventemplate <class _Rp> 1353232950Stheravenpromise<_Rp>::~promise() 1354227825Stheraven{ 1355227825Stheraven if (__state_) 1356227825Stheraven { 1357227825Stheraven if (!__state_->__has_value() && __state_->use_count() > 1) 1358227825Stheraven __state_->set_exception(make_exception_ptr( 1359227825Stheraven future_error(make_error_code(future_errc::broken_promise)) 1360227825Stheraven )); 1361227825Stheraven __state_->__release_shared(); 1362227825Stheraven } 1363227825Stheraven} 1364227825Stheraven 1365232950Stheraventemplate <class _Rp> 1366232950Stheravenfuture<_Rp> 1367232950Stheravenpromise<_Rp>::get_future() 1368227825Stheraven{ 1369227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1370227825Stheraven if (__state_ == nullptr) 1371227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1372227825Stheraven#endif 1373232950Stheraven return future<_Rp>(__state_); 1374227825Stheraven} 1375227825Stheraven 1376232950Stheraventemplate <class _Rp> 1377227825Stheravenvoid 1378232950Stheravenpromise<_Rp>::set_value(const _Rp& __r) 1379227825Stheraven{ 1380227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1381227825Stheraven if (__state_ == nullptr) 1382227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1383227825Stheraven#endif 1384227825Stheraven __state_->set_value(__r); 1385227825Stheraven} 1386227825Stheraven 1387227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1388227825Stheraven 1389232950Stheraventemplate <class _Rp> 1390227825Stheravenvoid 1391232950Stheravenpromise<_Rp>::set_value(_Rp&& __r) 1392227825Stheraven{ 1393227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1394227825Stheraven if (__state_ == nullptr) 1395227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1396227825Stheraven#endif 1397227825Stheraven __state_->set_value(_VSTD::move(__r)); 1398227825Stheraven} 1399227825Stheraven 1400227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1401227825Stheraven 1402232950Stheraventemplate <class _Rp> 1403227825Stheravenvoid 1404232950Stheravenpromise<_Rp>::set_exception(exception_ptr __p) 1405227825Stheraven{ 1406227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1407227825Stheraven if (__state_ == nullptr) 1408227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1409227825Stheraven#endif 1410227825Stheraven __state_->set_exception(__p); 1411227825Stheraven} 1412227825Stheraven 1413232950Stheraventemplate <class _Rp> 1414227825Stheravenvoid 1415232950Stheravenpromise<_Rp>::set_value_at_thread_exit(const _Rp& __r) 1416227825Stheraven{ 1417227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1418227825Stheraven if (__state_ == nullptr) 1419227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1420227825Stheraven#endif 1421227825Stheraven __state_->set_value_at_thread_exit(__r); 1422227825Stheraven} 1423227825Stheraven 1424227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1425227825Stheraven 1426232950Stheraventemplate <class _Rp> 1427227825Stheravenvoid 1428232950Stheravenpromise<_Rp>::set_value_at_thread_exit(_Rp&& __r) 1429227825Stheraven{ 1430227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1431227825Stheraven if (__state_ == nullptr) 1432227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1433227825Stheraven#endif 1434227825Stheraven __state_->set_value_at_thread_exit(_VSTD::move(__r)); 1435227825Stheraven} 1436227825Stheraven 1437227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1438227825Stheraven 1439232950Stheraventemplate <class _Rp> 1440227825Stheravenvoid 1441232950Stheravenpromise<_Rp>::set_exception_at_thread_exit(exception_ptr __p) 1442227825Stheraven{ 1443227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1444227825Stheraven if (__state_ == nullptr) 1445227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1446227825Stheraven#endif 1447227825Stheraven __state_->set_exception_at_thread_exit(__p); 1448227825Stheraven} 1449227825Stheraven 1450227825Stheraven// promise<R&> 1451227825Stheraven 1452232950Stheraventemplate <class _Rp> 1453232950Stheravenclass _LIBCPP_VISIBLE promise<_Rp&> 1454227825Stheraven{ 1455232950Stheraven __assoc_state<_Rp&>* __state_; 1456227825Stheraven 1457227825Stheraven _LIBCPP_INLINE_VISIBILITY 1458227825Stheraven explicit promise(nullptr_t) : __state_(nullptr) {} 1459227825Stheraven 1460227825Stheraven template <class> friend class packaged_task; 1461227825Stheraven 1462227825Stheravenpublic: 1463227825Stheraven promise(); 1464227825Stheraven template <class _Allocator> 1465227825Stheraven promise(allocator_arg_t, const _Allocator& __a); 1466227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1467227825Stheraven _LIBCPP_INLINE_VISIBILITY 1468227825Stheraven promise(promise&& __rhs) 1469227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1470227825Stheraven promise(const promise& __rhs) = delete; 1471227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1472227825Stheravenprivate: 1473227825Stheraven promise(const promise& __rhs); 1474227825Stheravenpublic: 1475227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1476227825Stheraven ~promise(); 1477227825Stheraven 1478227825Stheraven // assignment 1479227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1480227825Stheraven _LIBCPP_INLINE_VISIBILITY 1481227825Stheraven promise& operator=(promise&& __rhs) 1482227825Stheraven { 1483227825Stheraven promise(std::move(__rhs)).swap(*this); 1484227825Stheraven return *this; 1485227825Stheraven } 1486227825Stheraven promise& operator=(const promise& __rhs) = delete; 1487227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1488227825Stheravenprivate: 1489227825Stheraven promise& operator=(const promise& __rhs); 1490227825Stheravenpublic: 1491227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1492227825Stheraven _LIBCPP_INLINE_VISIBILITY 1493227825Stheraven void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1494227825Stheraven 1495227825Stheraven // retrieving the result 1496232950Stheraven future<_Rp&> get_future(); 1497227825Stheraven 1498227825Stheraven // setting the result 1499232950Stheraven void set_value(_Rp& __r); 1500227825Stheraven void set_exception(exception_ptr __p); 1501227825Stheraven 1502227825Stheraven // setting the result with deferred notification 1503232950Stheraven void set_value_at_thread_exit(_Rp&); 1504227825Stheraven void set_exception_at_thread_exit(exception_ptr __p); 1505227825Stheraven}; 1506227825Stheraven 1507232950Stheraventemplate <class _Rp> 1508232950Stheravenpromise<_Rp&>::promise() 1509232950Stheraven : __state_(new __assoc_state<_Rp&>) 1510227825Stheraven{ 1511227825Stheraven} 1512227825Stheraven 1513232950Stheraventemplate <class _Rp> 1514227825Stheraventemplate <class _Alloc> 1515232950Stheravenpromise<_Rp&>::promise(allocator_arg_t, const _Alloc& __a0) 1516227825Stheraven{ 1517232950Stheraven typedef typename _Alloc::template rebind<__assoc_state_alloc<_Rp&, _Alloc> >::other _A2; 1518227825Stheraven typedef __allocator_destructor<_A2> _D2; 1519227825Stheraven _A2 __a(__a0); 1520232950Stheraven unique_ptr<__assoc_state_alloc<_Rp&, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1)); 1521232950Stheraven ::new(__hold.get()) __assoc_state_alloc<_Rp&, _Alloc>(__a0); 1522227825Stheraven __state_ = __hold.release(); 1523227825Stheraven} 1524227825Stheraven 1525232950Stheraventemplate <class _Rp> 1526232950Stheravenpromise<_Rp&>::~promise() 1527227825Stheraven{ 1528227825Stheraven if (__state_) 1529227825Stheraven { 1530227825Stheraven if (!__state_->__has_value() && __state_->use_count() > 1) 1531227825Stheraven __state_->set_exception(make_exception_ptr( 1532227825Stheraven future_error(make_error_code(future_errc::broken_promise)) 1533227825Stheraven )); 1534227825Stheraven __state_->__release_shared(); 1535227825Stheraven } 1536227825Stheraven} 1537227825Stheraven 1538232950Stheraventemplate <class _Rp> 1539232950Stheravenfuture<_Rp&> 1540232950Stheravenpromise<_Rp&>::get_future() 1541227825Stheraven{ 1542227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1543227825Stheraven if (__state_ == nullptr) 1544227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1545227825Stheraven#endif 1546232950Stheraven return future<_Rp&>(__state_); 1547227825Stheraven} 1548227825Stheraven 1549232950Stheraventemplate <class _Rp> 1550227825Stheravenvoid 1551232950Stheravenpromise<_Rp&>::set_value(_Rp& __r) 1552227825Stheraven{ 1553227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1554227825Stheraven if (__state_ == nullptr) 1555227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1556227825Stheraven#endif 1557227825Stheraven __state_->set_value(__r); 1558227825Stheraven} 1559227825Stheraven 1560232950Stheraventemplate <class _Rp> 1561227825Stheravenvoid 1562232950Stheravenpromise<_Rp&>::set_exception(exception_ptr __p) 1563227825Stheraven{ 1564227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1565227825Stheraven if (__state_ == nullptr) 1566227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1567227825Stheraven#endif 1568227825Stheraven __state_->set_exception(__p); 1569227825Stheraven} 1570227825Stheraven 1571232950Stheraventemplate <class _Rp> 1572227825Stheravenvoid 1573232950Stheravenpromise<_Rp&>::set_value_at_thread_exit(_Rp& __r) 1574227825Stheraven{ 1575227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1576227825Stheraven if (__state_ == nullptr) 1577227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1578227825Stheraven#endif 1579227825Stheraven __state_->set_value_at_thread_exit(__r); 1580227825Stheraven} 1581227825Stheraven 1582232950Stheraventemplate <class _Rp> 1583227825Stheravenvoid 1584232950Stheravenpromise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p) 1585227825Stheraven{ 1586227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1587227825Stheraven if (__state_ == nullptr) 1588227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1589227825Stheraven#endif 1590227825Stheraven __state_->set_exception_at_thread_exit(__p); 1591227825Stheraven} 1592227825Stheraven 1593227825Stheraven// promise<void> 1594227825Stheraven 1595227825Stheraventemplate <> 1596227825Stheravenclass _LIBCPP_VISIBLE promise<void> 1597227825Stheraven{ 1598227825Stheraven __assoc_sub_state* __state_; 1599227825Stheraven 1600227825Stheraven _LIBCPP_INLINE_VISIBILITY 1601227825Stheraven explicit promise(nullptr_t) : __state_(nullptr) {} 1602227825Stheraven 1603227825Stheraven template <class> friend class packaged_task; 1604227825Stheraven 1605227825Stheravenpublic: 1606227825Stheraven promise(); 1607227825Stheraven template <class _Allocator> 1608227825Stheraven promise(allocator_arg_t, const _Allocator& __a); 1609227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1610227825Stheraven _LIBCPP_INLINE_VISIBILITY 1611227825Stheraven promise(promise&& __rhs) 1612227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1613227825Stheraven promise(const promise& __rhs) = delete; 1614227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1615227825Stheravenprivate: 1616227825Stheraven promise(const promise& __rhs); 1617227825Stheravenpublic: 1618227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1619227825Stheraven ~promise(); 1620227825Stheraven 1621227825Stheraven // assignment 1622227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1623227825Stheraven _LIBCPP_INLINE_VISIBILITY 1624227825Stheraven promise& operator=(promise&& __rhs) 1625227825Stheraven { 1626227825Stheraven promise(std::move(__rhs)).swap(*this); 1627227825Stheraven return *this; 1628227825Stheraven } 1629227825Stheraven promise& operator=(const promise& __rhs) = delete; 1630227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1631227825Stheravenprivate: 1632227825Stheraven promise& operator=(const promise& __rhs); 1633227825Stheravenpublic: 1634227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1635227825Stheraven _LIBCPP_INLINE_VISIBILITY 1636227825Stheraven void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1637227825Stheraven 1638227825Stheraven // retrieving the result 1639227825Stheraven future<void> get_future(); 1640227825Stheraven 1641227825Stheraven // setting the result 1642227825Stheraven void set_value(); 1643227825Stheraven void set_exception(exception_ptr __p); 1644227825Stheraven 1645227825Stheraven // setting the result with deferred notification 1646227825Stheraven void set_value_at_thread_exit(); 1647227825Stheraven void set_exception_at_thread_exit(exception_ptr __p); 1648227825Stheraven}; 1649227825Stheraven 1650227825Stheraventemplate <class _Alloc> 1651227825Stheravenpromise<void>::promise(allocator_arg_t, const _Alloc& __a0) 1652227825Stheraven{ 1653227825Stheraven typedef typename _Alloc::template rebind<__assoc_sub_state_alloc<_Alloc> >::other _A2; 1654227825Stheraven typedef __allocator_destructor<_A2> _D2; 1655227825Stheraven _A2 __a(__a0); 1656227825Stheraven unique_ptr<__assoc_sub_state_alloc<_Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1)); 1657227825Stheraven ::new(__hold.get()) __assoc_sub_state_alloc<_Alloc>(__a0); 1658227825Stheraven __state_ = __hold.release(); 1659227825Stheraven} 1660227825Stheraven 1661232950Stheraventemplate <class _Rp> 1662227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1663227825Stheravenvoid 1664232950Stheravenswap(promise<_Rp>& __x, promise<_Rp>& __y) 1665227825Stheraven{ 1666227825Stheraven __x.swap(__y); 1667227825Stheraven} 1668227825Stheraven 1669232950Stheraventemplate <class _Rp, class _Alloc> 1670232950Stheraven struct _LIBCPP_VISIBLE uses_allocator<promise<_Rp>, _Alloc> 1671227825Stheraven : public true_type {}; 1672227825Stheraven 1673227825Stheraven#ifndef _LIBCPP_HAS_NO_VARIADICS 1674227825Stheraven 1675227825Stheraven// packaged_task 1676227825Stheraven 1677227825Stheraventemplate<class _Fp> class __packaged_task_base; 1678227825Stheraven 1679232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1680232950Stheravenclass __packaged_task_base<_Rp(_ArgTypes...)> 1681227825Stheraven{ 1682227825Stheraven __packaged_task_base(const __packaged_task_base&); 1683227825Stheraven __packaged_task_base& operator=(const __packaged_task_base&); 1684227825Stheravenpublic: 1685227825Stheraven _LIBCPP_INLINE_VISIBILITY 1686227825Stheraven __packaged_task_base() {} 1687227825Stheraven _LIBCPP_INLINE_VISIBILITY 1688227825Stheraven virtual ~__packaged_task_base() {} 1689227825Stheraven virtual void __move_to(__packaged_task_base*) = 0; 1690227825Stheraven virtual void destroy() = 0; 1691227825Stheraven virtual void destroy_deallocate() = 0; 1692232950Stheraven virtual _Rp operator()(_ArgTypes&& ...) = 0; 1693227825Stheraven}; 1694227825Stheraven 1695227825Stheraventemplate<class _FD, class _Alloc, class _FB> class __packaged_task_func; 1696227825Stheraven 1697232950Stheraventemplate<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1698232950Stheravenclass __packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)> 1699232950Stheraven : public __packaged_task_base<_Rp(_ArgTypes...)> 1700227825Stheraven{ 1701232950Stheraven __compressed_pair<_Fp, _Alloc> __f_; 1702227825Stheravenpublic: 1703227825Stheraven _LIBCPP_INLINE_VISIBILITY 1704232950Stheraven explicit __packaged_task_func(const _Fp& __f) : __f_(__f) {} 1705227825Stheraven _LIBCPP_INLINE_VISIBILITY 1706232950Stheraven explicit __packaged_task_func(_Fp&& __f) : __f_(_VSTD::move(__f)) {} 1707227825Stheraven _LIBCPP_INLINE_VISIBILITY 1708232950Stheraven __packaged_task_func(const _Fp& __f, const _Alloc& __a) 1709227825Stheraven : __f_(__f, __a) {} 1710227825Stheraven _LIBCPP_INLINE_VISIBILITY 1711232950Stheraven __packaged_task_func(_Fp&& __f, const _Alloc& __a) 1712227825Stheraven : __f_(_VSTD::move(__f), __a) {} 1713232950Stheraven virtual void __move_to(__packaged_task_base<_Rp(_ArgTypes...)>*); 1714227825Stheraven virtual void destroy(); 1715227825Stheraven virtual void destroy_deallocate(); 1716232950Stheraven virtual _Rp operator()(_ArgTypes&& ... __args); 1717227825Stheraven}; 1718227825Stheraven 1719232950Stheraventemplate<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1720227825Stheravenvoid 1721232950Stheraven__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__move_to( 1722232950Stheraven __packaged_task_base<_Rp(_ArgTypes...)>* __p) 1723227825Stheraven{ 1724227825Stheraven ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second())); 1725227825Stheraven} 1726227825Stheraven 1727232950Stheraventemplate<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1728227825Stheravenvoid 1729232950Stheraven__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() 1730227825Stheraven{ 1731232950Stheraven __f_.~__compressed_pair<_Fp, _Alloc>(); 1732227825Stheraven} 1733227825Stheraven 1734232950Stheraventemplate<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1735227825Stheravenvoid 1736232950Stheraven__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() 1737227825Stheraven{ 1738232950Stheraven typedef typename _Alloc::template rebind<__packaged_task_func>::other _Ap; 1739232950Stheraven _Ap __a(__f_.second()); 1740232950Stheraven __f_.~__compressed_pair<_Fp, _Alloc>(); 1741227825Stheraven __a.deallocate(this, 1); 1742227825Stheraven} 1743227825Stheraven 1744232950Stheraventemplate<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes> 1745232950Stheraven_Rp 1746232950Stheraven__packaged_task_func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) 1747227825Stheraven{ 1748227825Stheraven return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); 1749227825Stheraven} 1750227825Stheraven 1751227825Stheraventemplate <class _Callable> class __packaged_task_function; 1752227825Stheraven 1753232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1754232950Stheravenclass __packaged_task_function<_Rp(_ArgTypes...)> 1755227825Stheraven{ 1756232950Stheraven typedef __packaged_task_base<_Rp(_ArgTypes...)> __base; 1757227825Stheraven aligned_storage<3*sizeof(void*)>::type __buf_; 1758227825Stheraven __base* __f_; 1759227825Stheraven 1760227825Stheravenpublic: 1761232950Stheraven typedef _Rp result_type; 1762227825Stheraven 1763227825Stheraven // construct/copy/destroy: 1764227825Stheraven _LIBCPP_INLINE_VISIBILITY 1765227825Stheraven __packaged_task_function() : __f_(nullptr) {} 1766232950Stheraven template<class _Fp> 1767232950Stheraven __packaged_task_function(_Fp&& __f); 1768232950Stheraven template<class _Fp, class _Alloc> 1769232950Stheraven __packaged_task_function(allocator_arg_t, const _Alloc& __a, _Fp&& __f); 1770227825Stheraven 1771227825Stheraven __packaged_task_function(__packaged_task_function&&); 1772227825Stheraven __packaged_task_function& operator=(__packaged_task_function&&); 1773227825Stheraven 1774227825Stheraven __packaged_task_function(const __packaged_task_function&) = delete; 1775227825Stheraven __packaged_task_function& operator=(const __packaged_task_function&) = delete; 1776227825Stheraven 1777227825Stheraven ~__packaged_task_function(); 1778227825Stheraven 1779227825Stheraven void swap(__packaged_task_function&); 1780227825Stheraven 1781232950Stheraven _Rp operator()(_ArgTypes...) const; 1782227825Stheraven}; 1783227825Stheraven 1784232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1785232950Stheraven__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) 1786227825Stheraven{ 1787227825Stheraven if (__f.__f_ == nullptr) 1788227825Stheraven __f_ = nullptr; 1789227825Stheraven else if (__f.__f_ == (__base*)&__f.__buf_) 1790227825Stheraven { 1791227825Stheraven __f_ = (__base*)&__buf_; 1792227825Stheraven __f.__f_->__move_to(__f_); 1793227825Stheraven } 1794227825Stheraven else 1795227825Stheraven { 1796227825Stheraven __f_ = __f.__f_; 1797227825Stheraven __f.__f_ = nullptr; 1798227825Stheraven } 1799227825Stheraven} 1800227825Stheraven 1801232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1802232950Stheraventemplate <class _Fp> 1803232950Stheraven__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function(_Fp&& __f) 1804227825Stheraven : __f_(nullptr) 1805227825Stheraven{ 1806232950Stheraven typedef typename remove_reference<_Fp>::type _FR; 1807232950Stheraven typedef __packaged_task_func<_FR, allocator<_FR>, _Rp(_ArgTypes...)> _FF; 1808227825Stheraven if (sizeof(_FF) <= sizeof(__buf_)) 1809227825Stheraven { 1810227825Stheraven __f_ = (__base*)&__buf_; 1811232950Stheraven ::new (__f_) _FF(_VSTD::forward<_Fp>(__f)); 1812227825Stheraven } 1813227825Stheraven else 1814227825Stheraven { 1815232950Stheraven typedef allocator<_FF> _Ap; 1816232950Stheraven _Ap __a; 1817232950Stheraven typedef __allocator_destructor<_Ap> _Dp; 1818232950Stheraven unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1819232950Stheraven ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), allocator<_FR>(__a)); 1820227825Stheraven __f_ = __hold.release(); 1821227825Stheraven } 1822227825Stheraven} 1823227825Stheraven 1824232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1825232950Stheraventemplate <class _Fp, class _Alloc> 1826232950Stheraven__packaged_task_function<_Rp(_ArgTypes...)>::__packaged_task_function( 1827232950Stheraven allocator_arg_t, const _Alloc& __a0, _Fp&& __f) 1828227825Stheraven : __f_(nullptr) 1829227825Stheraven{ 1830227825Stheraven typedef allocator_traits<_Alloc> __alloc_traits; 1831232950Stheraven typedef typename remove_reference<_Fp>::type _FR; 1832232950Stheraven typedef __packaged_task_func<_FR, _Alloc, _Rp(_ArgTypes...)> _FF; 1833227825Stheraven if (sizeof(_FF) <= sizeof(__buf_)) 1834227825Stheraven { 1835227825Stheraven __f_ = (__base*)&__buf_; 1836232950Stheraven ::new (__f_) _FF(_VSTD::forward<_Fp>(__f)); 1837227825Stheraven } 1838227825Stheraven else 1839227825Stheraven { 1840227825Stheraven typedef typename __alloc_traits::template 1841227825Stheraven#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1842227825Stheraven rebind_alloc<_FF> 1843227825Stheraven#else 1844227825Stheraven rebind_alloc<_FF>::other 1845227825Stheraven#endif 1846232950Stheraven _Ap; 1847232950Stheraven _Ap __a(__a0); 1848232950Stheraven typedef __allocator_destructor<_Ap> _Dp; 1849232950Stheraven unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1)); 1850232950Stheraven ::new (__hold.get()) _FF(_VSTD::forward<_Fp>(__f), _Alloc(__a)); 1851227825Stheraven __f_ = __hold.release(); 1852227825Stheraven } 1853227825Stheraven} 1854227825Stheraven 1855232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1856232950Stheraven__packaged_task_function<_Rp(_ArgTypes...)>& 1857232950Stheraven__packaged_task_function<_Rp(_ArgTypes...)>::operator=(__packaged_task_function&& __f) 1858227825Stheraven{ 1859227825Stheraven if (__f_ == (__base*)&__buf_) 1860227825Stheraven __f_->destroy(); 1861227825Stheraven else if (__f_) 1862227825Stheraven __f_->destroy_deallocate(); 1863227825Stheraven __f_ = nullptr; 1864227825Stheraven if (__f.__f_ == nullptr) 1865227825Stheraven __f_ = nullptr; 1866227825Stheraven else if (__f.__f_ == (__base*)&__f.__buf_) 1867227825Stheraven { 1868227825Stheraven __f_ = (__base*)&__buf_; 1869227825Stheraven __f.__f_->__move_to(__f_); 1870227825Stheraven } 1871227825Stheraven else 1872227825Stheraven { 1873227825Stheraven __f_ = __f.__f_; 1874227825Stheraven __f.__f_ = nullptr; 1875227825Stheraven } 1876227825Stheraven} 1877227825Stheraven 1878232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1879232950Stheraven__packaged_task_function<_Rp(_ArgTypes...)>::~__packaged_task_function() 1880227825Stheraven{ 1881227825Stheraven if (__f_ == (__base*)&__buf_) 1882227825Stheraven __f_->destroy(); 1883227825Stheraven else if (__f_) 1884227825Stheraven __f_->destroy_deallocate(); 1885227825Stheraven} 1886227825Stheraven 1887232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1888227825Stheravenvoid 1889232950Stheraven__packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) 1890227825Stheraven{ 1891227825Stheraven if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) 1892227825Stheraven { 1893227825Stheraven typename aligned_storage<sizeof(__buf_)>::type __tempbuf; 1894227825Stheraven __base* __t = (__base*)&__tempbuf; 1895227825Stheraven __f_->__move_to(__t); 1896227825Stheraven __f_->destroy(); 1897227825Stheraven __f_ = nullptr; 1898227825Stheraven __f.__f_->__move_to((__base*)&__buf_); 1899227825Stheraven __f.__f_->destroy(); 1900227825Stheraven __f.__f_ = nullptr; 1901227825Stheraven __f_ = (__base*)&__buf_; 1902227825Stheraven __t->__move_to((__base*)&__f.__buf_); 1903227825Stheraven __t->destroy(); 1904227825Stheraven __f.__f_ = (__base*)&__f.__buf_; 1905227825Stheraven } 1906227825Stheraven else if (__f_ == (__base*)&__buf_) 1907227825Stheraven { 1908227825Stheraven __f_->__move_to((__base*)&__f.__buf_); 1909227825Stheraven __f_->destroy(); 1910227825Stheraven __f_ = __f.__f_; 1911227825Stheraven __f.__f_ = (__base*)&__f.__buf_; 1912227825Stheraven } 1913227825Stheraven else if (__f.__f_ == (__base*)&__f.__buf_) 1914227825Stheraven { 1915227825Stheraven __f.__f_->__move_to((__base*)&__buf_); 1916227825Stheraven __f.__f_->destroy(); 1917227825Stheraven __f.__f_ = __f_; 1918227825Stheraven __f_ = (__base*)&__buf_; 1919227825Stheraven } 1920227825Stheraven else 1921227825Stheraven _VSTD::swap(__f_, __f.__f_); 1922227825Stheraven} 1923227825Stheraven 1924232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1925227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1926232950Stheraven_Rp 1927232950Stheraven__packaged_task_function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const 1928227825Stheraven{ 1929227825Stheraven return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...); 1930227825Stheraven} 1931227825Stheraven 1932232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1933232950Stheravenclass _LIBCPP_VISIBLE packaged_task<_Rp(_ArgTypes...)> 1934227825Stheraven{ 1935227825Stheravenpublic: 1936232950Stheraven typedef _Rp result_type; 1937227825Stheraven 1938227825Stheravenprivate: 1939227825Stheraven __packaged_task_function<result_type(_ArgTypes...)> __f_; 1940227825Stheraven promise<result_type> __p_; 1941227825Stheraven 1942227825Stheravenpublic: 1943227825Stheraven // construction and destruction 1944227825Stheraven _LIBCPP_INLINE_VISIBILITY 1945227825Stheraven packaged_task() : __p_(nullptr) {} 1946232950Stheraven template <class _Fp> 1947227825Stheraven _LIBCPP_INLINE_VISIBILITY 1948232950Stheraven explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {} 1949232950Stheraven template <class _Fp, class _Allocator> 1950227825Stheraven _LIBCPP_INLINE_VISIBILITY 1951232950Stheraven explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) 1952232950Stheraven : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), 1953227825Stheraven __p_(allocator_arg, __a) {} 1954227825Stheraven // ~packaged_task() = default; 1955227825Stheraven 1956227825Stheraven // no copy 1957227825Stheraven packaged_task(packaged_task&) = delete; 1958227825Stheraven packaged_task& operator=(packaged_task&) = delete; 1959227825Stheraven 1960227825Stheraven // move support 1961227825Stheraven _LIBCPP_INLINE_VISIBILITY 1962227825Stheraven packaged_task(packaged_task&& __other) 1963227825Stheraven : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {} 1964227825Stheraven _LIBCPP_INLINE_VISIBILITY 1965227825Stheraven packaged_task& operator=(packaged_task&& __other) 1966227825Stheraven { 1967227825Stheraven __f_ = _VSTD::move(__other.__f_); 1968227825Stheraven __p_ = _VSTD::move(__other.__p_); 1969227825Stheraven return *this; 1970227825Stheraven } 1971227825Stheraven _LIBCPP_INLINE_VISIBILITY 1972227825Stheraven void swap(packaged_task& __other) 1973227825Stheraven { 1974227825Stheraven __f_.swap(__other.__f_); 1975227825Stheraven __p_.swap(__other.__p_); 1976227825Stheraven } 1977227825Stheraven 1978227825Stheraven _LIBCPP_INLINE_VISIBILITY 1979227825Stheraven bool valid() const {return __p_.__state_ != nullptr;} 1980227825Stheraven 1981227825Stheraven // result retrieval 1982227825Stheraven _LIBCPP_INLINE_VISIBILITY 1983227825Stheraven future<result_type> get_future() {return __p_.get_future();} 1984227825Stheraven 1985227825Stheraven // execution 1986227825Stheraven void operator()(_ArgTypes... __args); 1987227825Stheraven void make_ready_at_thread_exit(_ArgTypes... __args); 1988227825Stheraven 1989227825Stheraven void reset(); 1990227825Stheraven}; 1991227825Stheraven 1992232950Stheraventemplate<class _Rp, class ..._ArgTypes> 1993227825Stheravenvoid 1994232950Stheravenpackaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args) 1995227825Stheraven{ 1996227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1997227825Stheraven if (__p_.__state_ == nullptr) 1998227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1999227825Stheraven if (__p_.__state_->__has_value()) 2000227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 2001227825Stheraven try 2002227825Stheraven { 2003227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2004227825Stheraven __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...)); 2005227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2006227825Stheraven } 2007227825Stheraven catch (...) 2008227825Stheraven { 2009227825Stheraven __p_.set_exception(current_exception()); 2010227825Stheraven } 2011227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2012227825Stheraven} 2013227825Stheraven 2014232950Stheraventemplate<class _Rp, class ..._ArgTypes> 2015227825Stheravenvoid 2016232950Stheravenpackaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) 2017227825Stheraven{ 2018227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2019227825Stheraven if (__p_.__state_ == nullptr) 2020227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2021227825Stheraven if (__p_.__state_->__has_value()) 2022227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 2023227825Stheraven try 2024227825Stheraven { 2025227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2026227825Stheraven __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...)); 2027227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2028227825Stheraven } 2029227825Stheraven catch (...) 2030227825Stheraven { 2031227825Stheraven __p_.set_exception_at_thread_exit(current_exception()); 2032227825Stheraven } 2033227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2034227825Stheraven} 2035227825Stheraven 2036232950Stheraventemplate<class _Rp, class ..._ArgTypes> 2037227825Stheravenvoid 2038232950Stheravenpackaged_task<_Rp(_ArgTypes...)>::reset() 2039227825Stheraven{ 2040227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2041227825Stheraven if (!valid()) 2042227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2043227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2044227825Stheraven __p_ = promise<result_type>(); 2045227825Stheraven} 2046227825Stheraven 2047227825Stheraventemplate<class ..._ArgTypes> 2048227825Stheravenclass _LIBCPP_VISIBLE packaged_task<void(_ArgTypes...)> 2049227825Stheraven{ 2050227825Stheravenpublic: 2051227825Stheraven typedef void result_type; 2052227825Stheraven 2053227825Stheravenprivate: 2054227825Stheraven __packaged_task_function<result_type(_ArgTypes...)> __f_; 2055227825Stheraven promise<result_type> __p_; 2056227825Stheraven 2057227825Stheravenpublic: 2058227825Stheraven // construction and destruction 2059227825Stheraven _LIBCPP_INLINE_VISIBILITY 2060227825Stheraven packaged_task() : __p_(nullptr) {} 2061232950Stheraven template <class _Fp> 2062227825Stheraven _LIBCPP_INLINE_VISIBILITY 2063232950Stheraven explicit packaged_task(_Fp&& __f) : __f_(_VSTD::forward<_Fp>(__f)) {} 2064232950Stheraven template <class _Fp, class _Allocator> 2065227825Stheraven _LIBCPP_INLINE_VISIBILITY 2066232950Stheraven explicit packaged_task(allocator_arg_t, const _Allocator& __a, _Fp&& __f) 2067232950Stheraven : __f_(allocator_arg, __a, _VSTD::forward<_Fp>(__f)), 2068227825Stheraven __p_(allocator_arg, __a) {} 2069227825Stheraven // ~packaged_task() = default; 2070227825Stheraven 2071227825Stheraven // no copy 2072227825Stheraven packaged_task(packaged_task&) = delete; 2073227825Stheraven packaged_task& operator=(packaged_task&) = delete; 2074227825Stheraven 2075227825Stheraven // move support 2076227825Stheraven _LIBCPP_INLINE_VISIBILITY 2077227825Stheraven packaged_task(packaged_task&& __other) 2078227825Stheraven : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {} 2079227825Stheraven _LIBCPP_INLINE_VISIBILITY 2080227825Stheraven packaged_task& operator=(packaged_task&& __other) 2081227825Stheraven { 2082227825Stheraven __f_ = _VSTD::move(__other.__f_); 2083227825Stheraven __p_ = _VSTD::move(__other.__p_); 2084227825Stheraven return *this; 2085227825Stheraven } 2086227825Stheraven _LIBCPP_INLINE_VISIBILITY 2087227825Stheraven void swap(packaged_task& __other) 2088227825Stheraven { 2089227825Stheraven __f_.swap(__other.__f_); 2090227825Stheraven __p_.swap(__other.__p_); 2091227825Stheraven } 2092227825Stheraven 2093227825Stheraven _LIBCPP_INLINE_VISIBILITY 2094227825Stheraven bool valid() const {return __p_.__state_ != nullptr;} 2095227825Stheraven 2096227825Stheraven // result retrieval 2097227825Stheraven _LIBCPP_INLINE_VISIBILITY 2098227825Stheraven future<result_type> get_future() {return __p_.get_future();} 2099227825Stheraven 2100227825Stheraven // execution 2101227825Stheraven void operator()(_ArgTypes... __args); 2102227825Stheraven void make_ready_at_thread_exit(_ArgTypes... __args); 2103227825Stheraven 2104227825Stheraven void reset(); 2105227825Stheraven}; 2106227825Stheraven 2107227825Stheraventemplate<class ..._ArgTypes> 2108227825Stheravenvoid 2109227825Stheravenpackaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args) 2110227825Stheraven{ 2111227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2112227825Stheraven if (__p_.__state_ == nullptr) 2113227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2114227825Stheraven if (__p_.__state_->__has_value()) 2115227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 2116227825Stheraven try 2117227825Stheraven { 2118227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2119227825Stheraven __f_(_VSTD::forward<_ArgTypes>(__args)...); 2120227825Stheraven __p_.set_value(); 2121227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2122227825Stheraven } 2123227825Stheraven catch (...) 2124227825Stheraven { 2125227825Stheraven __p_.set_exception(current_exception()); 2126227825Stheraven } 2127227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2128227825Stheraven} 2129227825Stheraven 2130227825Stheraventemplate<class ..._ArgTypes> 2131227825Stheravenvoid 2132227825Stheravenpackaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) 2133227825Stheraven{ 2134227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2135227825Stheraven if (__p_.__state_ == nullptr) 2136227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2137227825Stheraven if (__p_.__state_->__has_value()) 2138227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 2139227825Stheraven try 2140227825Stheraven { 2141227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2142227825Stheraven __f_(_VSTD::forward<_ArgTypes>(__args)...); 2143227825Stheraven __p_.set_value_at_thread_exit(); 2144227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2145227825Stheraven } 2146227825Stheraven catch (...) 2147227825Stheraven { 2148227825Stheraven __p_.set_exception_at_thread_exit(current_exception()); 2149227825Stheraven } 2150227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2151227825Stheraven} 2152227825Stheraven 2153227825Stheraventemplate<class ..._ArgTypes> 2154227825Stheravenvoid 2155227825Stheravenpackaged_task<void(_ArgTypes...)>::reset() 2156227825Stheraven{ 2157227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2158227825Stheraven if (!valid()) 2159227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2160227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2161227825Stheraven __p_ = promise<result_type>(); 2162227825Stheraven} 2163227825Stheraven 2164227825Stheraventemplate <class _Callable> 2165227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2166227825Stheravenvoid 2167227825Stheravenswap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) 2168227825Stheraven{ 2169227825Stheraven __x.swap(__y); 2170227825Stheraven} 2171227825Stheraven 2172227825Stheraventemplate <class _Callable, class _Alloc> 2173227825Stheravenstruct _LIBCPP_VISIBLE uses_allocator<packaged_task<_Callable>, _Alloc> 2174227825Stheraven : public true_type {}; 2175227825Stheraven 2176232950Stheraventemplate <class _Rp, class _Fp> 2177232950Stheravenfuture<_Rp> 2178227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2179232950Stheraven__make_deferred_assoc_state(_Fp&& __f) 2180227825Stheraven#else 2181232950Stheraven__make_deferred_assoc_state(_Fp __f) 2182227825Stheraven#endif 2183227825Stheraven{ 2184232950Stheraven unique_ptr<__deferred_assoc_state<_Rp, _Fp>, __release_shared_count> 2185232950Stheraven __h(new __deferred_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f))); 2186232950Stheraven return future<_Rp>(__h.get()); 2187227825Stheraven} 2188227825Stheraven 2189232950Stheraventemplate <class _Rp, class _Fp> 2190232950Stheravenfuture<_Rp> 2191227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2192232950Stheraven__make_async_assoc_state(_Fp&& __f) 2193227825Stheraven#else 2194232950Stheraven__make_async_assoc_state(_Fp __f) 2195227825Stheraven#endif 2196227825Stheraven{ 2197232950Stheraven unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count> 2198232950Stheraven __h(new __async_assoc_state<_Rp, _Fp>(_VSTD::forward<_Fp>(__f))); 2199232950Stheraven _VSTD::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach(); 2200232950Stheraven return future<_Rp>(__h.get()); 2201227825Stheraven} 2202227825Stheraven 2203232950Stheraventemplate <class _Fp, class... _Args> 2204227825Stheravenclass __async_func 2205227825Stheraven{ 2206232950Stheraven tuple<_Fp, _Args...> __f_; 2207227825Stheraven 2208227825Stheravenpublic: 2209232950Stheraven typedef typename __invoke_of<_Fp, _Args...>::type _Rp; 2210227825Stheraven 2211227825Stheraven _LIBCPP_INLINE_VISIBILITY 2212232950Stheraven explicit __async_func(_Fp&& __f, _Args&&... __args) 2213227825Stheraven : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {} 2214227825Stheraven 2215227825Stheraven _LIBCPP_INLINE_VISIBILITY 2216227825Stheraven __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {} 2217227825Stheraven 2218232950Stheraven _Rp operator()() 2219227825Stheraven { 2220227825Stheraven typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index; 2221227825Stheraven return __execute(_Index()); 2222227825Stheraven } 2223227825Stheravenprivate: 2224227825Stheraven template <size_t ..._Indices> 2225232950Stheraven _Rp 2226227825Stheraven __execute(__tuple_indices<_Indices...>) 2227227825Stheraven { 2228227825Stheraven return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...); 2229227825Stheraven } 2230227825Stheraven}; 2231227825Stheraven 2232232950Stheraventemplate <class _Fp, class... _Args> 2233232950Stheravenfuture<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type> 2234232950Stheravenasync(launch __policy, _Fp&& __f, _Args&&... __args) 2235227825Stheraven{ 2236232950Stheraven typedef __async_func<typename decay<_Fp>::type, typename decay<_Args>::type...> _BF; 2237232950Stheraven typedef typename _BF::_Rp _Rp; 2238232950Stheraven future<_Rp> __r; 2239232950Stheraven if (int(__policy) & int(launch::async)) 2240232950Stheraven __r = _VSTD::__make_async_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), 2241227825Stheraven __decay_copy(_VSTD::forward<_Args>(__args))...)); 2242232950Stheraven else if (int(__policy) & int(launch::deferred)) 2243232950Stheraven __r = _VSTD::__make_deferred_assoc_state<_Rp>(_BF(__decay_copy(_VSTD::forward<_Fp>(__f)), 2244227825Stheraven __decay_copy(_VSTD::forward<_Args>(__args))...)); 2245227825Stheraven return __r; 2246227825Stheraven} 2247227825Stheraven 2248232950Stheraventemplate <class _Fp, class... _Args> 2249227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2250232950Stheravenfuture<typename __invoke_of<typename decay<_Fp>::type, typename decay<_Args>::type...>::type> 2251232950Stheravenasync(_Fp&& __f, _Args&&... __args) 2252227825Stheraven{ 2253232950Stheraven return _VSTD::async(launch::any, _VSTD::forward<_Fp>(__f), 2254227825Stheraven _VSTD::forward<_Args>(__args)...); 2255227825Stheraven} 2256227825Stheraven 2257227825Stheraven#endif // _LIBCPP_HAS_NO_VARIADICS 2258227825Stheraven 2259227825Stheraven// shared_future 2260227825Stheraven 2261232950Stheraventemplate <class _Rp> 2262227825Stheravenclass _LIBCPP_VISIBLE shared_future 2263227825Stheraven{ 2264232950Stheraven __assoc_state<_Rp>* __state_; 2265227825Stheraven 2266227825Stheravenpublic: 2267227825Stheraven _LIBCPP_INLINE_VISIBILITY 2268227825Stheraven shared_future() : __state_(nullptr) {} 2269227825Stheraven _LIBCPP_INLINE_VISIBILITY 2270227825Stheraven shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) 2271227825Stheraven {if (__state_) __state_->__add_shared();} 2272227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2273227825Stheraven _LIBCPP_INLINE_VISIBILITY 2274232950Stheraven shared_future(future<_Rp>&& __f) : __state_(__f.__state_) 2275227825Stheraven {__f.__state_ = nullptr;} 2276227825Stheraven _LIBCPP_INLINE_VISIBILITY 2277227825Stheraven shared_future(shared_future&& __rhs) : __state_(__rhs.__state_) 2278227825Stheraven {__rhs.__state_ = nullptr;} 2279227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2280227825Stheraven ~shared_future(); 2281227825Stheraven shared_future& operator=(const shared_future& __rhs); 2282227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2283227825Stheraven _LIBCPP_INLINE_VISIBILITY 2284227825Stheraven shared_future& operator=(shared_future&& __rhs) 2285227825Stheraven { 2286227825Stheraven shared_future(std::move(__rhs)).swap(*this); 2287227825Stheraven return *this; 2288227825Stheraven } 2289227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2290227825Stheraven 2291227825Stheraven // retrieving the value 2292227825Stheraven _LIBCPP_INLINE_VISIBILITY 2293232950Stheraven const _Rp& get() const {return __state_->copy();} 2294227825Stheraven 2295227825Stheraven _LIBCPP_INLINE_VISIBILITY 2296227825Stheraven void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 2297227825Stheraven 2298227825Stheraven // functions to check state 2299227825Stheraven _LIBCPP_INLINE_VISIBILITY 2300227825Stheraven bool valid() const {return __state_ != nullptr;} 2301227825Stheraven 2302227825Stheraven _LIBCPP_INLINE_VISIBILITY 2303227825Stheraven void wait() const {__state_->wait();} 2304227825Stheraven template <class _Rep, class _Period> 2305227825Stheraven _LIBCPP_INLINE_VISIBILITY 2306227825Stheraven future_status 2307227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 2308227825Stheraven {return __state_->wait_for(__rel_time);} 2309227825Stheraven template <class _Clock, class _Duration> 2310227825Stheraven _LIBCPP_INLINE_VISIBILITY 2311227825Stheraven future_status 2312227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 2313227825Stheraven {return __state_->wait_until(__abs_time);} 2314227825Stheraven}; 2315227825Stheraven 2316232950Stheraventemplate <class _Rp> 2317232950Stheravenshared_future<_Rp>::~shared_future() 2318227825Stheraven{ 2319227825Stheraven if (__state_) 2320227825Stheraven __state_->__release_shared(); 2321227825Stheraven} 2322227825Stheraven 2323232950Stheraventemplate <class _Rp> 2324232950Stheravenshared_future<_Rp>& 2325232950Stheravenshared_future<_Rp>::operator=(const shared_future& __rhs) 2326227825Stheraven{ 2327227825Stheraven if (__rhs.__state_) 2328227825Stheraven __rhs.__state_->__add_shared(); 2329227825Stheraven if (__state_) 2330227825Stheraven __state_->__release_shared(); 2331227825Stheraven __state_ = __rhs.__state_; 2332227825Stheraven return *this; 2333227825Stheraven} 2334227825Stheraven 2335232950Stheraventemplate <class _Rp> 2336232950Stheravenclass _LIBCPP_VISIBLE shared_future<_Rp&> 2337227825Stheraven{ 2338232950Stheraven __assoc_state<_Rp&>* __state_; 2339227825Stheraven 2340227825Stheravenpublic: 2341227825Stheraven _LIBCPP_INLINE_VISIBILITY 2342227825Stheraven shared_future() : __state_(nullptr) {} 2343227825Stheraven _LIBCPP_INLINE_VISIBILITY 2344227825Stheraven shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) 2345227825Stheraven {if (__state_) __state_->__add_shared();} 2346227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2347227825Stheraven _LIBCPP_INLINE_VISIBILITY 2348232950Stheraven shared_future(future<_Rp&>&& __f) : __state_(__f.__state_) 2349227825Stheraven {__f.__state_ = nullptr;} 2350227825Stheraven _LIBCPP_INLINE_VISIBILITY 2351227825Stheraven shared_future(shared_future&& __rhs) : __state_(__rhs.__state_) 2352227825Stheraven {__rhs.__state_ = nullptr;} 2353227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2354227825Stheraven ~shared_future(); 2355227825Stheraven shared_future& operator=(const shared_future& __rhs); 2356227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2357227825Stheraven _LIBCPP_INLINE_VISIBILITY 2358227825Stheraven shared_future& operator=(shared_future&& __rhs) 2359227825Stheraven { 2360227825Stheraven shared_future(std::move(__rhs)).swap(*this); 2361227825Stheraven return *this; 2362227825Stheraven } 2363227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2364227825Stheraven 2365227825Stheraven // retrieving the value 2366227825Stheraven _LIBCPP_INLINE_VISIBILITY 2367232950Stheraven _Rp& get() const {return __state_->copy();} 2368227825Stheraven 2369227825Stheraven _LIBCPP_INLINE_VISIBILITY 2370227825Stheraven void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 2371227825Stheraven 2372227825Stheraven // functions to check state 2373227825Stheraven _LIBCPP_INLINE_VISIBILITY 2374227825Stheraven bool valid() const {return __state_ != nullptr;} 2375227825Stheraven 2376227825Stheraven _LIBCPP_INLINE_VISIBILITY 2377227825Stheraven void wait() const {__state_->wait();} 2378227825Stheraven template <class _Rep, class _Period> 2379227825Stheraven _LIBCPP_INLINE_VISIBILITY 2380227825Stheraven future_status 2381227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 2382227825Stheraven {return __state_->wait_for(__rel_time);} 2383227825Stheraven template <class _Clock, class _Duration> 2384227825Stheraven _LIBCPP_INLINE_VISIBILITY 2385227825Stheraven future_status 2386227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 2387227825Stheraven {return __state_->wait_until(__abs_time);} 2388227825Stheraven}; 2389227825Stheraven 2390232950Stheraventemplate <class _Rp> 2391232950Stheravenshared_future<_Rp&>::~shared_future() 2392227825Stheraven{ 2393227825Stheraven if (__state_) 2394227825Stheraven __state_->__release_shared(); 2395227825Stheraven} 2396227825Stheraven 2397232950Stheraventemplate <class _Rp> 2398232950Stheravenshared_future<_Rp&>& 2399232950Stheravenshared_future<_Rp&>::operator=(const shared_future& __rhs) 2400227825Stheraven{ 2401227825Stheraven if (__rhs.__state_) 2402227825Stheraven __rhs.__state_->__add_shared(); 2403227825Stheraven if (__state_) 2404227825Stheraven __state_->__release_shared(); 2405227825Stheraven __state_ = __rhs.__state_; 2406227825Stheraven return *this; 2407227825Stheraven} 2408227825Stheraven 2409227825Stheraventemplate <> 2410227825Stheravenclass _LIBCPP_VISIBLE shared_future<void> 2411227825Stheraven{ 2412227825Stheraven __assoc_sub_state* __state_; 2413227825Stheraven 2414227825Stheravenpublic: 2415227825Stheraven _LIBCPP_INLINE_VISIBILITY 2416227825Stheraven shared_future() : __state_(nullptr) {} 2417227825Stheraven _LIBCPP_INLINE_VISIBILITY 2418227825Stheraven shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) 2419227825Stheraven {if (__state_) __state_->__add_shared();} 2420227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2421227825Stheraven _LIBCPP_INLINE_VISIBILITY 2422227825Stheraven shared_future(future<void>&& __f) : __state_(__f.__state_) 2423227825Stheraven {__f.__state_ = nullptr;} 2424227825Stheraven _LIBCPP_INLINE_VISIBILITY 2425227825Stheraven shared_future(shared_future&& __rhs) : __state_(__rhs.__state_) 2426227825Stheraven {__rhs.__state_ = nullptr;} 2427227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2428227825Stheraven ~shared_future(); 2429227825Stheraven shared_future& operator=(const shared_future& __rhs); 2430227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2431227825Stheraven _LIBCPP_INLINE_VISIBILITY 2432227825Stheraven shared_future& operator=(shared_future&& __rhs) 2433227825Stheraven { 2434227825Stheraven shared_future(std::move(__rhs)).swap(*this); 2435227825Stheraven return *this; 2436227825Stheraven } 2437227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2438227825Stheraven 2439227825Stheraven // retrieving the value 2440227825Stheraven _LIBCPP_INLINE_VISIBILITY 2441227825Stheraven void get() const {__state_->copy();} 2442227825Stheraven 2443227825Stheraven _LIBCPP_INLINE_VISIBILITY 2444227825Stheraven void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 2445227825Stheraven 2446227825Stheraven // functions to check state 2447227825Stheraven _LIBCPP_INLINE_VISIBILITY 2448227825Stheraven bool valid() const {return __state_ != nullptr;} 2449227825Stheraven 2450227825Stheraven _LIBCPP_INLINE_VISIBILITY 2451227825Stheraven void wait() const {__state_->wait();} 2452227825Stheraven template <class _Rep, class _Period> 2453227825Stheraven _LIBCPP_INLINE_VISIBILITY 2454227825Stheraven future_status 2455227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 2456227825Stheraven {return __state_->wait_for(__rel_time);} 2457227825Stheraven template <class _Clock, class _Duration> 2458227825Stheraven _LIBCPP_INLINE_VISIBILITY 2459227825Stheraven future_status 2460227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 2461227825Stheraven {return __state_->wait_until(__abs_time);} 2462227825Stheraven}; 2463227825Stheraven 2464232950Stheraventemplate <class _Rp> 2465227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2466227825Stheravenvoid 2467232950Stheravenswap(shared_future<_Rp>& __x, shared_future<_Rp>& __y) 2468227825Stheraven{ 2469227825Stheraven __x.swap(__y); 2470227825Stheraven} 2471227825Stheraven 2472232950Stheraventemplate <class _Rp> 2473227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2474232950Stheravenshared_future<_Rp> 2475232950Stheravenfuture<_Rp>::share() 2476227825Stheraven{ 2477232950Stheraven return shared_future<_Rp>(_VSTD::move(*this)); 2478227825Stheraven} 2479227825Stheraven 2480232950Stheraventemplate <class _Rp> 2481227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2482232950Stheravenshared_future<_Rp&> 2483232950Stheravenfuture<_Rp&>::share() 2484227825Stheraven{ 2485232950Stheraven return shared_future<_Rp&>(_VSTD::move(*this)); 2486227825Stheraven} 2487227825Stheraven 2488227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2489227825Stheraven 2490227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2491227825Stheravenshared_future<void> 2492227825Stheravenfuture<void>::share() 2493227825Stheraven{ 2494227825Stheraven return shared_future<void>(_VSTD::move(*this)); 2495227825Stheraven} 2496227825Stheraven 2497227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2498227825Stheraven 2499227825Stheraven_LIBCPP_END_NAMESPACE_STD 2500227825Stheraven 2501227825Stheraven#endif // _LIBCPP_FUTURE 2502