future revision 227825
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 380227825Stheravenstruct _LIBCPP_VISIBLE future_errc 381227825Stheraven{ 382227825Stheravenenum _ { 383227825Stheraven broken_promise, 384227825Stheraven future_already_retrieved, 385227825Stheraven promise_already_satisfied, 386227825Stheraven no_state 387227825Stheraven}; 388227825Stheraven 389227825Stheraven _ __v_; 390227825Stheraven 391227825Stheraven _LIBCPP_INLINE_VISIBILITY future_errc(_ __v) : __v_(__v) {} 392227825Stheraven _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} 393227825Stheraven 394227825Stheraven}; 395227825Stheraven 396227825Stheraventemplate <> 397227825Stheravenstruct _LIBCPP_VISIBLE is_error_code_enum<future_errc> : public true_type {}; 398227825Stheraven 399227825Stheraven//enum class launch 400227825Stheravenstruct _LIBCPP_VISIBLE launch 401227825Stheraven{ 402227825Stheravenenum _ { 403227825Stheraven async = 1, 404227825Stheraven deferred = 2, 405227825Stheraven any = async | deferred 406227825Stheraven}; 407227825Stheraven 408227825Stheraven _ __v_; 409227825Stheraven 410227825Stheraven _LIBCPP_INLINE_VISIBILITY launch(_ __v) : __v_(__v) {} 411227825Stheraven _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} 412227825Stheraven 413227825Stheraven}; 414227825Stheraven 415227825Stheraven//enum class future_status 416227825Stheravenstruct _LIBCPP_VISIBLE future_status 417227825Stheraven{ 418227825Stheravenenum _ { 419227825Stheraven ready, 420227825Stheraven timeout, 421227825Stheraven deferred 422227825Stheraven}; 423227825Stheraven 424227825Stheraven _ __v_; 425227825Stheraven 426227825Stheraven _LIBCPP_INLINE_VISIBILITY future_status(_ __v) : __v_(__v) {} 427227825Stheraven _LIBCPP_INLINE_VISIBILITY operator int() const {return __v_;} 428227825Stheraven 429227825Stheraven}; 430227825Stheraven 431227825Stheraven_LIBCPP_VISIBLE 432227825Stheravenconst error_category& future_category(); 433227825Stheraven 434227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 435227825Stheravenerror_code 436227825Stheravenmake_error_code(future_errc __e) 437227825Stheraven{ 438227825Stheraven return error_code(static_cast<int>(__e), future_category()); 439227825Stheraven} 440227825Stheraven 441227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 442227825Stheravenerror_condition 443227825Stheravenmake_error_condition(future_errc __e) 444227825Stheraven{ 445227825Stheraven return error_condition(static_cast<int>(__e), future_category()); 446227825Stheraven} 447227825Stheraven 448227825Stheravenclass _LIBCPP_EXCEPTION_ABI future_error 449227825Stheraven : public logic_error 450227825Stheraven{ 451227825Stheraven error_code __ec_; 452227825Stheravenpublic: 453227825Stheraven future_error(error_code __ec); 454227825Stheraven 455227825Stheraven _LIBCPP_INLINE_VISIBILITY 456227825Stheraven const error_code& code() const throw() {return __ec_;} 457227825Stheraven 458227825Stheraven virtual ~future_error() _NOEXCEPT; 459227825Stheraven}; 460227825Stheraven 461227825Stheravenclass __assoc_sub_state 462227825Stheraven : public __shared_count 463227825Stheraven{ 464227825Stheravenprotected: 465227825Stheraven exception_ptr __exception_; 466227825Stheraven mutable mutex __mut_; 467227825Stheraven mutable condition_variable __cv_; 468227825Stheraven unsigned __state_; 469227825Stheraven 470227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 471227825Stheraven void __sub_wait(unique_lock<mutex>& __lk); 472227825Stheravenpublic: 473227825Stheraven enum 474227825Stheraven { 475227825Stheraven __constructed = 1, 476227825Stheraven __future_attached = 2, 477227825Stheraven ready = 4, 478227825Stheraven deferred = 8 479227825Stheraven }; 480227825Stheraven 481227825Stheraven _LIBCPP_INLINE_VISIBILITY 482227825Stheraven __assoc_sub_state() : __state_(0) {} 483227825Stheraven 484227825Stheraven _LIBCPP_INLINE_VISIBILITY 485227825Stheraven bool __has_value() const 486227825Stheraven {return (__state_ & __constructed) || (__exception_ != nullptr);} 487227825Stheraven 488227825Stheraven _LIBCPP_INLINE_VISIBILITY 489227825Stheraven void __set_future_attached() {__state_ |= __future_attached;} 490227825Stheraven _LIBCPP_INLINE_VISIBILITY 491227825Stheraven bool __has_future_attached() const {return __state_ & __future_attached;} 492227825Stheraven 493227825Stheraven _LIBCPP_INLINE_VISIBILITY 494227825Stheraven void __set_deferred() {__state_ |= deferred;} 495227825Stheraven 496227825Stheraven void __make_ready(); 497227825Stheraven _LIBCPP_INLINE_VISIBILITY 498227825Stheraven bool __is_ready() const {return __state_ & ready;} 499227825Stheraven 500227825Stheraven void set_value(); 501227825Stheraven void set_value_at_thread_exit(); 502227825Stheraven 503227825Stheraven void set_exception(exception_ptr __p); 504227825Stheraven void set_exception_at_thread_exit(exception_ptr __p); 505227825Stheraven 506227825Stheraven void copy(); 507227825Stheraven 508227825Stheraven void wait(); 509227825Stheraven template <class _Rep, class _Period> 510227825Stheraven future_status 511227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const; 512227825Stheraven template <class _Clock, class _Duration> 513227825Stheraven future_status 514227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const; 515227825Stheraven 516227825Stheraven virtual void __execute(); 517227825Stheraven}; 518227825Stheraven 519227825Stheraventemplate <class _Clock, class _Duration> 520227825Stheravenfuture_status 521227825Stheraven__assoc_sub_state::wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 522227825Stheraven{ 523227825Stheraven unique_lock<mutex> __lk(__mut_); 524227825Stheraven if (__state_ & deferred) 525227825Stheraven return future_status::deferred; 526227825Stheraven while (!(__state_ & ready) && _Clock::now() < __abs_time) 527227825Stheraven __cv_.wait_until(__lk, __abs_time); 528227825Stheraven if (__state_ & ready) 529227825Stheraven return future_status::ready; 530227825Stheraven return future_status::timeout; 531227825Stheraven} 532227825Stheraven 533227825Stheraventemplate <class _Rep, class _Period> 534227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 535227825Stheravenfuture_status 536227825Stheraven__assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 537227825Stheraven{ 538227825Stheraven return wait_until(chrono::steady_clock::now() + __rel_time); 539227825Stheraven} 540227825Stheraven 541227825Stheraventemplate <class _R> 542227825Stheravenclass __assoc_state 543227825Stheraven : public __assoc_sub_state 544227825Stheraven{ 545227825Stheraven typedef __assoc_sub_state base; 546227825Stheraven typedef typename aligned_storage<sizeof(_R), alignment_of<_R>::value>::type _U; 547227825Stheravenprotected: 548227825Stheraven _U __value_; 549227825Stheraven 550227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 551227825Stheravenpublic: 552227825Stheraven 553227825Stheraven template <class _Arg> 554227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 555227825Stheraven void set_value(_Arg&& __arg); 556227825Stheraven#else 557227825Stheraven void set_value(_Arg& __arg); 558227825Stheraven#endif 559227825Stheraven 560227825Stheraven template <class _Arg> 561227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 562227825Stheraven void set_value_at_thread_exit(_Arg&& __arg); 563227825Stheraven#else 564227825Stheraven void set_value_at_thread_exit(_Arg& __arg); 565227825Stheraven#endif 566227825Stheraven 567227825Stheraven _R move(); 568227825Stheraven typename add_lvalue_reference<_R>::type copy(); 569227825Stheraven}; 570227825Stheraven 571227825Stheraventemplate <class _R> 572227825Stheravenvoid 573227825Stheraven__assoc_state<_R>::__on_zero_shared() _NOEXCEPT 574227825Stheraven{ 575227825Stheraven if (this->__state_ & base::__constructed) 576227825Stheraven reinterpret_cast<_R*>(&__value_)->~_R(); 577227825Stheraven delete this; 578227825Stheraven} 579227825Stheraven 580227825Stheraventemplate <class _R> 581227825Stheraventemplate <class _Arg> 582227825Stheravenvoid 583227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 584227825Stheraven__assoc_state<_R>::set_value(_Arg&& __arg) 585227825Stheraven#else 586227825Stheraven__assoc_state<_R>::set_value(_Arg& __arg) 587227825Stheraven#endif 588227825Stheraven{ 589227825Stheraven unique_lock<mutex> __lk(this->__mut_); 590227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 591227825Stheraven if (this->__has_value()) 592227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 593227825Stheraven#endif 594227825Stheraven ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg)); 595227825Stheraven this->__state_ |= base::__constructed | base::ready; 596227825Stheraven __lk.unlock(); 597227825Stheraven __cv_.notify_all(); 598227825Stheraven} 599227825Stheraven 600227825Stheraventemplate <class _R> 601227825Stheraventemplate <class _Arg> 602227825Stheravenvoid 603227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 604227825Stheraven__assoc_state<_R>::set_value_at_thread_exit(_Arg&& __arg) 605227825Stheraven#else 606227825Stheraven__assoc_state<_R>::set_value_at_thread_exit(_Arg& __arg) 607227825Stheraven#endif 608227825Stheraven{ 609227825Stheraven unique_lock<mutex> __lk(this->__mut_); 610227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 611227825Stheraven if (this->__has_value()) 612227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 613227825Stheraven#endif 614227825Stheraven ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg)); 615227825Stheraven this->__state_ |= base::__constructed; 616227825Stheraven __thread_local_data()->__make_ready_at_thread_exit(this); 617227825Stheraven __lk.unlock(); 618227825Stheraven} 619227825Stheraven 620227825Stheraventemplate <class _R> 621227825Stheraven_R 622227825Stheraven__assoc_state<_R>::move() 623227825Stheraven{ 624227825Stheraven unique_lock<mutex> __lk(this->__mut_); 625227825Stheraven this->__sub_wait(__lk); 626227825Stheraven if (this->__exception_ != nullptr) 627227825Stheraven rethrow_exception(this->__exception_); 628227825Stheraven return _VSTD::move(*reinterpret_cast<_R*>(&__value_)); 629227825Stheraven} 630227825Stheraven 631227825Stheraventemplate <class _R> 632227825Stheraventypename add_lvalue_reference<_R>::type 633227825Stheraven__assoc_state<_R>::copy() 634227825Stheraven{ 635227825Stheraven unique_lock<mutex> __lk(this->__mut_); 636227825Stheraven this->__sub_wait(__lk); 637227825Stheraven if (this->__exception_ != nullptr) 638227825Stheraven rethrow_exception(this->__exception_); 639227825Stheraven return *reinterpret_cast<_R*>(&__value_); 640227825Stheraven} 641227825Stheraven 642227825Stheraventemplate <class _R> 643227825Stheravenclass __assoc_state<_R&> 644227825Stheraven : public __assoc_sub_state 645227825Stheraven{ 646227825Stheraven typedef __assoc_sub_state base; 647227825Stheraven typedef _R* _U; 648227825Stheravenprotected: 649227825Stheraven _U __value_; 650227825Stheraven 651227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 652227825Stheravenpublic: 653227825Stheraven 654227825Stheraven void set_value(_R& __arg); 655227825Stheraven void set_value_at_thread_exit(_R& __arg); 656227825Stheraven 657227825Stheraven _R& copy(); 658227825Stheraven}; 659227825Stheraven 660227825Stheraventemplate <class _R> 661227825Stheravenvoid 662227825Stheraven__assoc_state<_R&>::__on_zero_shared() _NOEXCEPT 663227825Stheraven{ 664227825Stheraven delete this; 665227825Stheraven} 666227825Stheraven 667227825Stheraventemplate <class _R> 668227825Stheravenvoid 669227825Stheraven__assoc_state<_R&>::set_value(_R& __arg) 670227825Stheraven{ 671227825Stheraven unique_lock<mutex> __lk(this->__mut_); 672227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 673227825Stheraven if (this->__has_value()) 674227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 675227825Stheraven#endif 676227825Stheraven __value_ = &__arg; 677227825Stheraven this->__state_ |= base::__constructed | base::ready; 678227825Stheraven __lk.unlock(); 679227825Stheraven __cv_.notify_all(); 680227825Stheraven} 681227825Stheraven 682227825Stheraventemplate <class _R> 683227825Stheravenvoid 684227825Stheraven__assoc_state<_R&>::set_value_at_thread_exit(_R& __arg) 685227825Stheraven{ 686227825Stheraven unique_lock<mutex> __lk(this->__mut_); 687227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 688227825Stheraven if (this->__has_value()) 689227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 690227825Stheraven#endif 691227825Stheraven __value_ = &__arg; 692227825Stheraven this->__state_ |= base::__constructed; 693227825Stheraven __thread_local_data()->__make_ready_at_thread_exit(this); 694227825Stheraven __lk.unlock(); 695227825Stheraven} 696227825Stheraven 697227825Stheraventemplate <class _R> 698227825Stheraven_R& 699227825Stheraven__assoc_state<_R&>::copy() 700227825Stheraven{ 701227825Stheraven unique_lock<mutex> __lk(this->__mut_); 702227825Stheraven this->__sub_wait(__lk); 703227825Stheraven if (this->__exception_ != nullptr) 704227825Stheraven rethrow_exception(this->__exception_); 705227825Stheraven return *__value_; 706227825Stheraven} 707227825Stheraven 708227825Stheraventemplate <class _R, class _Alloc> 709227825Stheravenclass __assoc_state_alloc 710227825Stheraven : public __assoc_state<_R> 711227825Stheraven{ 712227825Stheraven typedef __assoc_state<_R> base; 713227825Stheraven _Alloc __alloc_; 714227825Stheraven 715227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 716227825Stheravenpublic: 717227825Stheraven _LIBCPP_INLINE_VISIBILITY 718227825Stheraven explicit __assoc_state_alloc(const _Alloc& __a) 719227825Stheraven : __alloc_(__a) {} 720227825Stheraven}; 721227825Stheraven 722227825Stheraventemplate <class _R, class _Alloc> 723227825Stheravenvoid 724227825Stheraven__assoc_state_alloc<_R, _Alloc>::__on_zero_shared() _NOEXCEPT 725227825Stheraven{ 726227825Stheraven if (this->__state_ & base::__constructed) 727227825Stheraven reinterpret_cast<_R*>(&this->__value_)->~_R(); 728227825Stheraven typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_); 729227825Stheraven this->~__assoc_state_alloc(); 730227825Stheraven __a.deallocate(this, 1); 731227825Stheraven} 732227825Stheraven 733227825Stheraventemplate <class _R, class _Alloc> 734227825Stheravenclass __assoc_state_alloc<_R&, _Alloc> 735227825Stheraven : public __assoc_state<_R&> 736227825Stheraven{ 737227825Stheraven typedef __assoc_state<_R&> base; 738227825Stheraven _Alloc __alloc_; 739227825Stheraven 740227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 741227825Stheravenpublic: 742227825Stheraven _LIBCPP_INLINE_VISIBILITY 743227825Stheraven explicit __assoc_state_alloc(const _Alloc& __a) 744227825Stheraven : __alloc_(__a) {} 745227825Stheraven}; 746227825Stheraven 747227825Stheraventemplate <class _R, class _Alloc> 748227825Stheravenvoid 749227825Stheraven__assoc_state_alloc<_R&, _Alloc>::__on_zero_shared() _NOEXCEPT 750227825Stheraven{ 751227825Stheraven typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_); 752227825Stheraven this->~__assoc_state_alloc(); 753227825Stheraven __a.deallocate(this, 1); 754227825Stheraven} 755227825Stheraven 756227825Stheraventemplate <class _Alloc> 757227825Stheravenclass __assoc_sub_state_alloc 758227825Stheraven : public __assoc_sub_state 759227825Stheraven{ 760227825Stheraven typedef __assoc_sub_state base; 761227825Stheraven _Alloc __alloc_; 762227825Stheraven 763227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 764227825Stheravenpublic: 765227825Stheraven _LIBCPP_INLINE_VISIBILITY 766227825Stheraven explicit __assoc_sub_state_alloc(const _Alloc& __a) 767227825Stheraven : __alloc_(__a) {} 768227825Stheraven}; 769227825Stheraven 770227825Stheraventemplate <class _Alloc> 771227825Stheravenvoid 772227825Stheraven__assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT 773227825Stheraven{ 774227825Stheraven this->~base(); 775227825Stheraven typename _Alloc::template rebind<__assoc_sub_state_alloc>::other __a(__alloc_); 776227825Stheraven this->~__assoc_sub_state_alloc(); 777227825Stheraven __a.deallocate(this, 1); 778227825Stheraven} 779227825Stheraven 780227825Stheraventemplate <class _R, class _F> 781227825Stheravenclass __deferred_assoc_state 782227825Stheraven : public __assoc_state<_R> 783227825Stheraven{ 784227825Stheraven typedef __assoc_state<_R> base; 785227825Stheraven 786227825Stheraven _F __func_; 787227825Stheraven 788227825Stheravenpublic: 789227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 790227825Stheraven explicit __deferred_assoc_state(_F&& __f); 791227825Stheraven#endif 792227825Stheraven 793227825Stheraven virtual void __execute(); 794227825Stheraven}; 795227825Stheraven 796227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 797227825Stheraven 798227825Stheraventemplate <class _R, class _F> 799227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 800227825Stheraven__deferred_assoc_state<_R, _F>::__deferred_assoc_state(_F&& __f) 801227825Stheraven : __func_(_VSTD::forward<_F>(__f)) 802227825Stheraven{ 803227825Stheraven this->__set_deferred(); 804227825Stheraven} 805227825Stheraven 806227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 807227825Stheraven 808227825Stheraventemplate <class _R, class _F> 809227825Stheravenvoid 810227825Stheraven__deferred_assoc_state<_R, _F>::__execute() 811227825Stheraven{ 812227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 813227825Stheraven try 814227825Stheraven { 815227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 816227825Stheraven this->set_value(__func_()); 817227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 818227825Stheraven } 819227825Stheraven catch (...) 820227825Stheraven { 821227825Stheraven this->set_exception(current_exception()); 822227825Stheraven } 823227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 824227825Stheraven} 825227825Stheraven 826227825Stheraventemplate <class _F> 827227825Stheravenclass __deferred_assoc_state<void, _F> 828227825Stheraven : public __assoc_sub_state 829227825Stheraven{ 830227825Stheraven typedef __assoc_sub_state base; 831227825Stheraven 832227825Stheraven _F __func_; 833227825Stheraven 834227825Stheravenpublic: 835227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 836227825Stheraven explicit __deferred_assoc_state(_F&& __f); 837227825Stheraven#endif 838227825Stheraven 839227825Stheraven virtual void __execute(); 840227825Stheraven}; 841227825Stheraven 842227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 843227825Stheraven 844227825Stheraventemplate <class _F> 845227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 846227825Stheraven__deferred_assoc_state<void, _F>::__deferred_assoc_state(_F&& __f) 847227825Stheraven : __func_(_VSTD::forward<_F>(__f)) 848227825Stheraven{ 849227825Stheraven this->__set_deferred(); 850227825Stheraven} 851227825Stheraven 852227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 853227825Stheraven 854227825Stheraventemplate <class _F> 855227825Stheravenvoid 856227825Stheraven__deferred_assoc_state<void, _F>::__execute() 857227825Stheraven{ 858227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 859227825Stheraven try 860227825Stheraven { 861227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 862227825Stheraven __func_(); 863227825Stheraven this->set_value(); 864227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 865227825Stheraven } 866227825Stheraven catch (...) 867227825Stheraven { 868227825Stheraven this->set_exception(current_exception()); 869227825Stheraven } 870227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 871227825Stheraven} 872227825Stheraven 873227825Stheraventemplate <class _R, class _F> 874227825Stheravenclass __async_assoc_state 875227825Stheraven : public __assoc_state<_R> 876227825Stheraven{ 877227825Stheraven typedef __assoc_state<_R> base; 878227825Stheraven 879227825Stheraven _F __func_; 880227825Stheraven 881227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 882227825Stheravenpublic: 883227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 884227825Stheraven explicit __async_assoc_state(_F&& __f); 885227825Stheraven#endif 886227825Stheraven 887227825Stheraven virtual void __execute(); 888227825Stheraven}; 889227825Stheraven 890227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 891227825Stheraven 892227825Stheraventemplate <class _R, class _F> 893227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 894227825Stheraven__async_assoc_state<_R, _F>::__async_assoc_state(_F&& __f) 895227825Stheraven : __func_(_VSTD::forward<_F>(__f)) 896227825Stheraven{ 897227825Stheraven} 898227825Stheraven 899227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 900227825Stheraven 901227825Stheraventemplate <class _R, class _F> 902227825Stheravenvoid 903227825Stheraven__async_assoc_state<_R, _F>::__execute() 904227825Stheraven{ 905227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 906227825Stheraven try 907227825Stheraven { 908227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 909227825Stheraven this->set_value(__func_()); 910227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 911227825Stheraven } 912227825Stheraven catch (...) 913227825Stheraven { 914227825Stheraven this->set_exception(current_exception()); 915227825Stheraven } 916227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 917227825Stheraven} 918227825Stheraven 919227825Stheraventemplate <class _R, class _F> 920227825Stheravenvoid 921227825Stheraven__async_assoc_state<_R, _F>::__on_zero_shared() _NOEXCEPT 922227825Stheraven{ 923227825Stheraven this->wait(); 924227825Stheraven base::__on_zero_shared(); 925227825Stheraven} 926227825Stheraven 927227825Stheraventemplate <class _F> 928227825Stheravenclass __async_assoc_state<void, _F> 929227825Stheraven : public __assoc_sub_state 930227825Stheraven{ 931227825Stheraven typedef __assoc_sub_state base; 932227825Stheraven 933227825Stheraven _F __func_; 934227825Stheraven 935227825Stheraven virtual void __on_zero_shared() _NOEXCEPT; 936227825Stheravenpublic: 937227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 938227825Stheraven explicit __async_assoc_state(_F&& __f); 939227825Stheraven#endif 940227825Stheraven 941227825Stheraven virtual void __execute(); 942227825Stheraven}; 943227825Stheraven 944227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 945227825Stheraven 946227825Stheraventemplate <class _F> 947227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 948227825Stheraven__async_assoc_state<void, _F>::__async_assoc_state(_F&& __f) 949227825Stheraven : __func_(_VSTD::forward<_F>(__f)) 950227825Stheraven{ 951227825Stheraven} 952227825Stheraven 953227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 954227825Stheraven 955227825Stheraventemplate <class _F> 956227825Stheravenvoid 957227825Stheraven__async_assoc_state<void, _F>::__execute() 958227825Stheraven{ 959227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 960227825Stheraven try 961227825Stheraven { 962227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 963227825Stheraven __func_(); 964227825Stheraven this->set_value(); 965227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 966227825Stheraven } 967227825Stheraven catch (...) 968227825Stheraven { 969227825Stheraven this->set_exception(current_exception()); 970227825Stheraven } 971227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 972227825Stheraven} 973227825Stheraven 974227825Stheraventemplate <class _F> 975227825Stheravenvoid 976227825Stheraven__async_assoc_state<void, _F>::__on_zero_shared() _NOEXCEPT 977227825Stheraven{ 978227825Stheraven this->wait(); 979227825Stheraven base::__on_zero_shared(); 980227825Stheraven} 981227825Stheraven 982227825Stheraventemplate <class _R> class promise; 983227825Stheraventemplate <class _R> class shared_future; 984227825Stheraven 985227825Stheraven// future 986227825Stheraven 987227825Stheraventemplate <class _R> class future; 988227825Stheraven 989227825Stheraventemplate <class _R, class _F> 990227825Stheravenfuture<_R> 991227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 992227825Stheraven__make_deferred_assoc_state(_F&& __f); 993227825Stheraven#else 994227825Stheraven__make_deferred_assoc_state(_F __f); 995227825Stheraven#endif 996227825Stheraven 997227825Stheraventemplate <class _R, class _F> 998227825Stheravenfuture<_R> 999227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1000227825Stheraven__make_async_assoc_state(_F&& __f); 1001227825Stheraven#else 1002227825Stheraven__make_async_assoc_state(_F __f); 1003227825Stheraven#endif 1004227825Stheraven 1005227825Stheraventemplate <class _R> 1006227825Stheravenclass _LIBCPP_VISIBLE future 1007227825Stheraven{ 1008227825Stheraven __assoc_state<_R>* __state_; 1009227825Stheraven 1010227825Stheraven explicit future(__assoc_state<_R>* __state); 1011227825Stheraven 1012227825Stheraven template <class> friend class promise; 1013227825Stheraven template <class> friend class shared_future; 1014227825Stheraven 1015227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1016227825Stheraven template <class _R1, class _F> 1017227825Stheraven friend future<_R1> __make_deferred_assoc_state(_F&& __f); 1018227825Stheraven template <class _R1, class _F> 1019227825Stheraven friend future<_R1> __make_async_assoc_state(_F&& __f); 1020227825Stheraven#else 1021227825Stheraven template <class _R1, class _F> 1022227825Stheraven friend future<_R1> __make_deferred_assoc_state(_F __f); 1023227825Stheraven template <class _R1, class _F> 1024227825Stheraven friend future<_R1> __make_async_assoc_state(_F __f); 1025227825Stheraven#endif 1026227825Stheraven 1027227825Stheravenpublic: 1028227825Stheraven _LIBCPP_INLINE_VISIBILITY 1029227825Stheraven future() : __state_(nullptr) {} 1030227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1031227825Stheraven _LIBCPP_INLINE_VISIBILITY 1032227825Stheraven future(future&& __rhs) 1033227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1034227825Stheraven future(const future&) = delete; 1035227825Stheraven future& operator=(const future&) = delete; 1036227825Stheraven _LIBCPP_INLINE_VISIBILITY 1037227825Stheraven future& operator=(future&& __rhs) 1038227825Stheraven { 1039227825Stheraven future(std::move(__rhs)).swap(*this); 1040227825Stheraven return *this; 1041227825Stheraven } 1042227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1043227825Stheravenprivate: 1044227825Stheraven future(const future&); 1045227825Stheraven future& operator=(const future&); 1046227825Stheravenpublic: 1047227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1048227825Stheraven ~future(); 1049227825Stheraven shared_future<_R> share(); 1050227825Stheraven 1051227825Stheraven // retrieving the value 1052227825Stheraven _R get(); 1053227825Stheraven 1054227825Stheraven _LIBCPP_INLINE_VISIBILITY 1055227825Stheraven void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1056227825Stheraven 1057227825Stheraven // functions to check state 1058227825Stheraven _LIBCPP_INLINE_VISIBILITY 1059227825Stheraven bool valid() const {return __state_ != nullptr;} 1060227825Stheraven 1061227825Stheraven _LIBCPP_INLINE_VISIBILITY 1062227825Stheraven void wait() const {__state_->wait();} 1063227825Stheraven template <class _Rep, class _Period> 1064227825Stheraven _LIBCPP_INLINE_VISIBILITY 1065227825Stheraven future_status 1066227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 1067227825Stheraven {return __state_->wait_for(__rel_time);} 1068227825Stheraven template <class _Clock, class _Duration> 1069227825Stheraven _LIBCPP_INLINE_VISIBILITY 1070227825Stheraven future_status 1071227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 1072227825Stheraven {return __state_->wait_until(__abs_time);} 1073227825Stheraven}; 1074227825Stheraven 1075227825Stheraventemplate <class _R> 1076227825Stheravenfuture<_R>::future(__assoc_state<_R>* __state) 1077227825Stheraven : __state_(__state) 1078227825Stheraven{ 1079227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1080227825Stheraven if (__state_->__has_future_attached()) 1081227825Stheraven throw future_error(make_error_code(future_errc::future_already_retrieved)); 1082227825Stheraven#endif 1083227825Stheraven __state_->__add_shared(); 1084227825Stheraven __state_->__set_future_attached(); 1085227825Stheraven} 1086227825Stheraven 1087227825Stheravenstruct __release_shared_count 1088227825Stheraven{ 1089227825Stheraven void operator()(__shared_count* p) {p->__release_shared();} 1090227825Stheraven}; 1091227825Stheraven 1092227825Stheraventemplate <class _R> 1093227825Stheravenfuture<_R>::~future() 1094227825Stheraven{ 1095227825Stheraven if (__state_) 1096227825Stheraven __state_->__release_shared(); 1097227825Stheraven} 1098227825Stheraven 1099227825Stheraventemplate <class _R> 1100227825Stheraven_R 1101227825Stheravenfuture<_R>::get() 1102227825Stheraven{ 1103227825Stheraven unique_ptr<__shared_count, __release_shared_count> __(__state_); 1104227825Stheraven __assoc_state<_R>* __s = __state_; 1105227825Stheraven __state_ = nullptr; 1106227825Stheraven return __s->move(); 1107227825Stheraven} 1108227825Stheraven 1109227825Stheraventemplate <class _R> 1110227825Stheravenclass _LIBCPP_VISIBLE future<_R&> 1111227825Stheraven{ 1112227825Stheraven __assoc_state<_R&>* __state_; 1113227825Stheraven 1114227825Stheraven explicit future(__assoc_state<_R&>* __state); 1115227825Stheraven 1116227825Stheraven template <class> friend class promise; 1117227825Stheraven template <class> friend class shared_future; 1118227825Stheraven 1119227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1120227825Stheraven template <class _R1, class _F> 1121227825Stheraven friend future<_R1> __make_deferred_assoc_state(_F&& __f); 1122227825Stheraven template <class _R1, class _F> 1123227825Stheraven friend future<_R1> __make_async_assoc_state(_F&& __f); 1124227825Stheraven#else 1125227825Stheraven template <class _R1, class _F> 1126227825Stheraven friend future<_R1> __make_deferred_assoc_state(_F __f); 1127227825Stheraven template <class _R1, class _F> 1128227825Stheraven friend future<_R1> __make_async_assoc_state(_F __f); 1129227825Stheraven#endif 1130227825Stheraven 1131227825Stheravenpublic: 1132227825Stheraven _LIBCPP_INLINE_VISIBILITY 1133227825Stheraven future() : __state_(nullptr) {} 1134227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1135227825Stheraven _LIBCPP_INLINE_VISIBILITY 1136227825Stheraven future(future&& __rhs) 1137227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1138227825Stheraven future(const future&) = delete; 1139227825Stheraven future& operator=(const future&) = delete; 1140227825Stheraven _LIBCPP_INLINE_VISIBILITY 1141227825Stheraven future& operator=(future&& __rhs) 1142227825Stheraven { 1143227825Stheraven future(std::move(__rhs)).swap(*this); 1144227825Stheraven return *this; 1145227825Stheraven } 1146227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1147227825Stheravenprivate: 1148227825Stheraven future(const future&); 1149227825Stheraven future& operator=(const future&); 1150227825Stheravenpublic: 1151227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1152227825Stheraven ~future(); 1153227825Stheraven shared_future<_R&> share(); 1154227825Stheraven 1155227825Stheraven // retrieving the value 1156227825Stheraven _R& get(); 1157227825Stheraven 1158227825Stheraven _LIBCPP_INLINE_VISIBILITY 1159227825Stheraven void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1160227825Stheraven 1161227825Stheraven // functions to check state 1162227825Stheraven _LIBCPP_INLINE_VISIBILITY 1163227825Stheraven bool valid() const {return __state_ != nullptr;} 1164227825Stheraven 1165227825Stheraven _LIBCPP_INLINE_VISIBILITY 1166227825Stheraven void wait() const {__state_->wait();} 1167227825Stheraven template <class _Rep, class _Period> 1168227825Stheraven _LIBCPP_INLINE_VISIBILITY 1169227825Stheraven future_status 1170227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 1171227825Stheraven {return __state_->wait_for(__rel_time);} 1172227825Stheraven template <class _Clock, class _Duration> 1173227825Stheraven _LIBCPP_INLINE_VISIBILITY 1174227825Stheraven future_status 1175227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 1176227825Stheraven {return __state_->wait_until(__abs_time);} 1177227825Stheraven}; 1178227825Stheraven 1179227825Stheraventemplate <class _R> 1180227825Stheravenfuture<_R&>::future(__assoc_state<_R&>* __state) 1181227825Stheraven : __state_(__state) 1182227825Stheraven{ 1183227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1184227825Stheraven if (__state_->__has_future_attached()) 1185227825Stheraven throw future_error(make_error_code(future_errc::future_already_retrieved)); 1186227825Stheraven#endif 1187227825Stheraven __state_->__add_shared(); 1188227825Stheraven __state_->__set_future_attached(); 1189227825Stheraven} 1190227825Stheraven 1191227825Stheraventemplate <class _R> 1192227825Stheravenfuture<_R&>::~future() 1193227825Stheraven{ 1194227825Stheraven if (__state_) 1195227825Stheraven __state_->__release_shared(); 1196227825Stheraven} 1197227825Stheraven 1198227825Stheraventemplate <class _R> 1199227825Stheraven_R& 1200227825Stheravenfuture<_R&>::get() 1201227825Stheraven{ 1202227825Stheraven unique_ptr<__shared_count, __release_shared_count> __(__state_); 1203227825Stheraven __assoc_state<_R&>* __s = __state_; 1204227825Stheraven __state_ = nullptr; 1205227825Stheraven return __s->copy(); 1206227825Stheraven} 1207227825Stheraven 1208227825Stheraventemplate <> 1209227825Stheravenclass _LIBCPP_VISIBLE future<void> 1210227825Stheraven{ 1211227825Stheraven __assoc_sub_state* __state_; 1212227825Stheraven 1213227825Stheraven explicit future(__assoc_sub_state* __state); 1214227825Stheraven 1215227825Stheraven template <class> friend class promise; 1216227825Stheraven template <class> friend class shared_future; 1217227825Stheraven 1218227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1219227825Stheraven template <class _R1, class _F> 1220227825Stheraven friend future<_R1> __make_deferred_assoc_state(_F&& __f); 1221227825Stheraven template <class _R1, class _F> 1222227825Stheraven friend future<_R1> __make_async_assoc_state(_F&& __f); 1223227825Stheraven#else 1224227825Stheraven template <class _R1, class _F> 1225227825Stheraven friend future<_R1> __make_deferred_assoc_state(_F __f); 1226227825Stheraven template <class _R1, class _F> 1227227825Stheraven friend future<_R1> __make_async_assoc_state(_F __f); 1228227825Stheraven#endif 1229227825Stheraven 1230227825Stheravenpublic: 1231227825Stheraven _LIBCPP_INLINE_VISIBILITY 1232227825Stheraven future() : __state_(nullptr) {} 1233227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1234227825Stheraven _LIBCPP_INLINE_VISIBILITY 1235227825Stheraven future(future&& __rhs) 1236227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1237227825Stheraven future(const future&) = delete; 1238227825Stheraven future& operator=(const future&) = delete; 1239227825Stheraven _LIBCPP_INLINE_VISIBILITY 1240227825Stheraven future& operator=(future&& __rhs) 1241227825Stheraven { 1242227825Stheraven future(std::move(__rhs)).swap(*this); 1243227825Stheraven return *this; 1244227825Stheraven } 1245227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1246227825Stheravenprivate: 1247227825Stheraven future(const future&); 1248227825Stheraven future& operator=(const future&); 1249227825Stheravenpublic: 1250227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1251227825Stheraven ~future(); 1252227825Stheraven shared_future<void> share(); 1253227825Stheraven 1254227825Stheraven // retrieving the value 1255227825Stheraven void get(); 1256227825Stheraven 1257227825Stheraven _LIBCPP_INLINE_VISIBILITY 1258227825Stheraven void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1259227825Stheraven 1260227825Stheraven // functions to check state 1261227825Stheraven _LIBCPP_INLINE_VISIBILITY 1262227825Stheraven bool valid() const {return __state_ != nullptr;} 1263227825Stheraven 1264227825Stheraven _LIBCPP_INLINE_VISIBILITY 1265227825Stheraven void wait() const {__state_->wait();} 1266227825Stheraven template <class _Rep, class _Period> 1267227825Stheraven _LIBCPP_INLINE_VISIBILITY 1268227825Stheraven future_status 1269227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 1270227825Stheraven {return __state_->wait_for(__rel_time);} 1271227825Stheraven template <class _Clock, class _Duration> 1272227825Stheraven _LIBCPP_INLINE_VISIBILITY 1273227825Stheraven future_status 1274227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 1275227825Stheraven {return __state_->wait_until(__abs_time);} 1276227825Stheraven}; 1277227825Stheraven 1278227825Stheraventemplate <class _R> 1279227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1280227825Stheravenvoid 1281227825Stheravenswap(future<_R>& __x, future<_R>& __y) 1282227825Stheraven{ 1283227825Stheraven __x.swap(__y); 1284227825Stheraven} 1285227825Stheraven 1286227825Stheraven// promise<R> 1287227825Stheraven 1288227825Stheraventemplate <class _Callable> class packaged_task; 1289227825Stheraven 1290227825Stheraventemplate <class _R> 1291227825Stheravenclass _LIBCPP_VISIBLE promise 1292227825Stheraven{ 1293227825Stheraven __assoc_state<_R>* __state_; 1294227825Stheraven 1295227825Stheraven _LIBCPP_INLINE_VISIBILITY 1296227825Stheraven explicit promise(nullptr_t) : __state_(nullptr) {} 1297227825Stheraven 1298227825Stheraven template <class> friend class packaged_task; 1299227825Stheravenpublic: 1300227825Stheraven promise(); 1301227825Stheraven template <class _Alloc> 1302227825Stheraven promise(allocator_arg_t, const _Alloc& __a); 1303227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1304227825Stheraven _LIBCPP_INLINE_VISIBILITY 1305227825Stheraven promise(promise&& __rhs) 1306227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1307227825Stheraven promise(const promise& __rhs) = delete; 1308227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1309227825Stheravenprivate: 1310227825Stheraven promise(const promise& __rhs); 1311227825Stheravenpublic: 1312227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1313227825Stheraven ~promise(); 1314227825Stheraven 1315227825Stheraven // assignment 1316227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1317227825Stheraven _LIBCPP_INLINE_VISIBILITY 1318227825Stheraven promise& operator=(promise&& __rhs) 1319227825Stheraven { 1320227825Stheraven promise(std::move(__rhs)).swap(*this); 1321227825Stheraven return *this; 1322227825Stheraven } 1323227825Stheraven promise& operator=(const promise& __rhs) = delete; 1324227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1325227825Stheravenprivate: 1326227825Stheraven promise& operator=(const promise& __rhs); 1327227825Stheravenpublic: 1328227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1329227825Stheraven _LIBCPP_INLINE_VISIBILITY 1330227825Stheraven void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1331227825Stheraven 1332227825Stheraven // retrieving the result 1333227825Stheraven future<_R> get_future(); 1334227825Stheraven 1335227825Stheraven // setting the result 1336227825Stheraven void set_value(const _R& __r); 1337227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1338227825Stheraven void set_value(_R&& __r); 1339227825Stheraven#endif 1340227825Stheraven void set_exception(exception_ptr __p); 1341227825Stheraven 1342227825Stheraven // setting the result with deferred notification 1343227825Stheraven void set_value_at_thread_exit(const _R& __r); 1344227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1345227825Stheraven void set_value_at_thread_exit(_R&& __r); 1346227825Stheraven#endif 1347227825Stheraven void set_exception_at_thread_exit(exception_ptr __p); 1348227825Stheraven}; 1349227825Stheraven 1350227825Stheraventemplate <class _R> 1351227825Stheravenpromise<_R>::promise() 1352227825Stheraven : __state_(new __assoc_state<_R>) 1353227825Stheraven{ 1354227825Stheraven} 1355227825Stheraven 1356227825Stheraventemplate <class _R> 1357227825Stheraventemplate <class _Alloc> 1358227825Stheravenpromise<_R>::promise(allocator_arg_t, const _Alloc& __a0) 1359227825Stheraven{ 1360227825Stheraven typedef typename _Alloc::template rebind<__assoc_state_alloc<_R, _Alloc> >::other _A2; 1361227825Stheraven typedef __allocator_destructor<_A2> _D2; 1362227825Stheraven _A2 __a(__a0); 1363227825Stheraven unique_ptr<__assoc_state_alloc<_R, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1)); 1364227825Stheraven ::new(__hold.get()) __assoc_state_alloc<_R, _Alloc>(__a0); 1365227825Stheraven __state_ = __hold.release(); 1366227825Stheraven} 1367227825Stheraven 1368227825Stheraventemplate <class _R> 1369227825Stheravenpromise<_R>::~promise() 1370227825Stheraven{ 1371227825Stheraven if (__state_) 1372227825Stheraven { 1373227825Stheraven if (!__state_->__has_value() && __state_->use_count() > 1) 1374227825Stheraven __state_->set_exception(make_exception_ptr( 1375227825Stheraven future_error(make_error_code(future_errc::broken_promise)) 1376227825Stheraven )); 1377227825Stheraven __state_->__release_shared(); 1378227825Stheraven } 1379227825Stheraven} 1380227825Stheraven 1381227825Stheraventemplate <class _R> 1382227825Stheravenfuture<_R> 1383227825Stheravenpromise<_R>::get_future() 1384227825Stheraven{ 1385227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1386227825Stheraven if (__state_ == nullptr) 1387227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1388227825Stheraven#endif 1389227825Stheraven return future<_R>(__state_); 1390227825Stheraven} 1391227825Stheraven 1392227825Stheraventemplate <class _R> 1393227825Stheravenvoid 1394227825Stheravenpromise<_R>::set_value(const _R& __r) 1395227825Stheraven{ 1396227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1397227825Stheraven if (__state_ == nullptr) 1398227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1399227825Stheraven#endif 1400227825Stheraven __state_->set_value(__r); 1401227825Stheraven} 1402227825Stheraven 1403227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1404227825Stheraven 1405227825Stheraventemplate <class _R> 1406227825Stheravenvoid 1407227825Stheravenpromise<_R>::set_value(_R&& __r) 1408227825Stheraven{ 1409227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1410227825Stheraven if (__state_ == nullptr) 1411227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1412227825Stheraven#endif 1413227825Stheraven __state_->set_value(_VSTD::move(__r)); 1414227825Stheraven} 1415227825Stheraven 1416227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1417227825Stheraven 1418227825Stheraventemplate <class _R> 1419227825Stheravenvoid 1420227825Stheravenpromise<_R>::set_exception(exception_ptr __p) 1421227825Stheraven{ 1422227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1423227825Stheraven if (__state_ == nullptr) 1424227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1425227825Stheraven#endif 1426227825Stheraven __state_->set_exception(__p); 1427227825Stheraven} 1428227825Stheraven 1429227825Stheraventemplate <class _R> 1430227825Stheravenvoid 1431227825Stheravenpromise<_R>::set_value_at_thread_exit(const _R& __r) 1432227825Stheraven{ 1433227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1434227825Stheraven if (__state_ == nullptr) 1435227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1436227825Stheraven#endif 1437227825Stheraven __state_->set_value_at_thread_exit(__r); 1438227825Stheraven} 1439227825Stheraven 1440227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1441227825Stheraven 1442227825Stheraventemplate <class _R> 1443227825Stheravenvoid 1444227825Stheravenpromise<_R>::set_value_at_thread_exit(_R&& __r) 1445227825Stheraven{ 1446227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1447227825Stheraven if (__state_ == nullptr) 1448227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1449227825Stheraven#endif 1450227825Stheraven __state_->set_value_at_thread_exit(_VSTD::move(__r)); 1451227825Stheraven} 1452227825Stheraven 1453227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1454227825Stheraven 1455227825Stheraventemplate <class _R> 1456227825Stheravenvoid 1457227825Stheravenpromise<_R>::set_exception_at_thread_exit(exception_ptr __p) 1458227825Stheraven{ 1459227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1460227825Stheraven if (__state_ == nullptr) 1461227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1462227825Stheraven#endif 1463227825Stheraven __state_->set_exception_at_thread_exit(__p); 1464227825Stheraven} 1465227825Stheraven 1466227825Stheraven// promise<R&> 1467227825Stheraven 1468227825Stheraventemplate <class _R> 1469227825Stheravenclass _LIBCPP_VISIBLE promise<_R&> 1470227825Stheraven{ 1471227825Stheraven __assoc_state<_R&>* __state_; 1472227825Stheraven 1473227825Stheraven _LIBCPP_INLINE_VISIBILITY 1474227825Stheraven explicit promise(nullptr_t) : __state_(nullptr) {} 1475227825Stheraven 1476227825Stheraven template <class> friend class packaged_task; 1477227825Stheraven 1478227825Stheravenpublic: 1479227825Stheraven promise(); 1480227825Stheraven template <class _Allocator> 1481227825Stheraven promise(allocator_arg_t, const _Allocator& __a); 1482227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1483227825Stheraven _LIBCPP_INLINE_VISIBILITY 1484227825Stheraven promise(promise&& __rhs) 1485227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1486227825Stheraven promise(const promise& __rhs) = delete; 1487227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1488227825Stheravenprivate: 1489227825Stheraven promise(const promise& __rhs); 1490227825Stheravenpublic: 1491227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1492227825Stheraven ~promise(); 1493227825Stheraven 1494227825Stheraven // assignment 1495227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1496227825Stheraven _LIBCPP_INLINE_VISIBILITY 1497227825Stheraven promise& operator=(promise&& __rhs) 1498227825Stheraven { 1499227825Stheraven promise(std::move(__rhs)).swap(*this); 1500227825Stheraven return *this; 1501227825Stheraven } 1502227825Stheraven promise& operator=(const promise& __rhs) = delete; 1503227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1504227825Stheravenprivate: 1505227825Stheraven promise& operator=(const promise& __rhs); 1506227825Stheravenpublic: 1507227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1508227825Stheraven _LIBCPP_INLINE_VISIBILITY 1509227825Stheraven void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1510227825Stheraven 1511227825Stheraven // retrieving the result 1512227825Stheraven future<_R&> get_future(); 1513227825Stheraven 1514227825Stheraven // setting the result 1515227825Stheraven void set_value(_R& __r); 1516227825Stheraven void set_exception(exception_ptr __p); 1517227825Stheraven 1518227825Stheraven // setting the result with deferred notification 1519227825Stheraven void set_value_at_thread_exit(_R&); 1520227825Stheraven void set_exception_at_thread_exit(exception_ptr __p); 1521227825Stheraven}; 1522227825Stheraven 1523227825Stheraventemplate <class _R> 1524227825Stheravenpromise<_R&>::promise() 1525227825Stheraven : __state_(new __assoc_state<_R&>) 1526227825Stheraven{ 1527227825Stheraven} 1528227825Stheraven 1529227825Stheraventemplate <class _R> 1530227825Stheraventemplate <class _Alloc> 1531227825Stheravenpromise<_R&>::promise(allocator_arg_t, const _Alloc& __a0) 1532227825Stheraven{ 1533227825Stheraven typedef typename _Alloc::template rebind<__assoc_state_alloc<_R&, _Alloc> >::other _A2; 1534227825Stheraven typedef __allocator_destructor<_A2> _D2; 1535227825Stheraven _A2 __a(__a0); 1536227825Stheraven unique_ptr<__assoc_state_alloc<_R&, _Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1)); 1537227825Stheraven ::new(__hold.get()) __assoc_state_alloc<_R&, _Alloc>(__a0); 1538227825Stheraven __state_ = __hold.release(); 1539227825Stheraven} 1540227825Stheraven 1541227825Stheraventemplate <class _R> 1542227825Stheravenpromise<_R&>::~promise() 1543227825Stheraven{ 1544227825Stheraven if (__state_) 1545227825Stheraven { 1546227825Stheraven if (!__state_->__has_value() && __state_->use_count() > 1) 1547227825Stheraven __state_->set_exception(make_exception_ptr( 1548227825Stheraven future_error(make_error_code(future_errc::broken_promise)) 1549227825Stheraven )); 1550227825Stheraven __state_->__release_shared(); 1551227825Stheraven } 1552227825Stheraven} 1553227825Stheraven 1554227825Stheraventemplate <class _R> 1555227825Stheravenfuture<_R&> 1556227825Stheravenpromise<_R&>::get_future() 1557227825Stheraven{ 1558227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1559227825Stheraven if (__state_ == nullptr) 1560227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1561227825Stheraven#endif 1562227825Stheraven return future<_R&>(__state_); 1563227825Stheraven} 1564227825Stheraven 1565227825Stheraventemplate <class _R> 1566227825Stheravenvoid 1567227825Stheravenpromise<_R&>::set_value(_R& __r) 1568227825Stheraven{ 1569227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1570227825Stheraven if (__state_ == nullptr) 1571227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1572227825Stheraven#endif 1573227825Stheraven __state_->set_value(__r); 1574227825Stheraven} 1575227825Stheraven 1576227825Stheraventemplate <class _R> 1577227825Stheravenvoid 1578227825Stheravenpromise<_R&>::set_exception(exception_ptr __p) 1579227825Stheraven{ 1580227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1581227825Stheraven if (__state_ == nullptr) 1582227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1583227825Stheraven#endif 1584227825Stheraven __state_->set_exception(__p); 1585227825Stheraven} 1586227825Stheraven 1587227825Stheraventemplate <class _R> 1588227825Stheravenvoid 1589227825Stheravenpromise<_R&>::set_value_at_thread_exit(_R& __r) 1590227825Stheraven{ 1591227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1592227825Stheraven if (__state_ == nullptr) 1593227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1594227825Stheraven#endif 1595227825Stheraven __state_->set_value_at_thread_exit(__r); 1596227825Stheraven} 1597227825Stheraven 1598227825Stheraventemplate <class _R> 1599227825Stheravenvoid 1600227825Stheravenpromise<_R&>::set_exception_at_thread_exit(exception_ptr __p) 1601227825Stheraven{ 1602227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 1603227825Stheraven if (__state_ == nullptr) 1604227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 1605227825Stheraven#endif 1606227825Stheraven __state_->set_exception_at_thread_exit(__p); 1607227825Stheraven} 1608227825Stheraven 1609227825Stheraven// promise<void> 1610227825Stheraven 1611227825Stheraventemplate <> 1612227825Stheravenclass _LIBCPP_VISIBLE promise<void> 1613227825Stheraven{ 1614227825Stheraven __assoc_sub_state* __state_; 1615227825Stheraven 1616227825Stheraven _LIBCPP_INLINE_VISIBILITY 1617227825Stheraven explicit promise(nullptr_t) : __state_(nullptr) {} 1618227825Stheraven 1619227825Stheraven template <class> friend class packaged_task; 1620227825Stheraven 1621227825Stheravenpublic: 1622227825Stheraven promise(); 1623227825Stheraven template <class _Allocator> 1624227825Stheraven promise(allocator_arg_t, const _Allocator& __a); 1625227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1626227825Stheraven _LIBCPP_INLINE_VISIBILITY 1627227825Stheraven promise(promise&& __rhs) 1628227825Stheraven : __state_(__rhs.__state_) {__rhs.__state_ = nullptr;} 1629227825Stheraven promise(const promise& __rhs) = delete; 1630227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1631227825Stheravenprivate: 1632227825Stheraven promise(const promise& __rhs); 1633227825Stheravenpublic: 1634227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1635227825Stheraven ~promise(); 1636227825Stheraven 1637227825Stheraven // assignment 1638227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 1639227825Stheraven _LIBCPP_INLINE_VISIBILITY 1640227825Stheraven promise& operator=(promise&& __rhs) 1641227825Stheraven { 1642227825Stheraven promise(std::move(__rhs)).swap(*this); 1643227825Stheraven return *this; 1644227825Stheraven } 1645227825Stheraven promise& operator=(const promise& __rhs) = delete; 1646227825Stheraven#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1647227825Stheravenprivate: 1648227825Stheraven promise& operator=(const promise& __rhs); 1649227825Stheravenpublic: 1650227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 1651227825Stheraven _LIBCPP_INLINE_VISIBILITY 1652227825Stheraven void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 1653227825Stheraven 1654227825Stheraven // retrieving the result 1655227825Stheraven future<void> get_future(); 1656227825Stheraven 1657227825Stheraven // setting the result 1658227825Stheraven void set_value(); 1659227825Stheraven void set_exception(exception_ptr __p); 1660227825Stheraven 1661227825Stheraven // setting the result with deferred notification 1662227825Stheraven void set_value_at_thread_exit(); 1663227825Stheraven void set_exception_at_thread_exit(exception_ptr __p); 1664227825Stheraven}; 1665227825Stheraven 1666227825Stheraventemplate <class _Alloc> 1667227825Stheravenpromise<void>::promise(allocator_arg_t, const _Alloc& __a0) 1668227825Stheraven{ 1669227825Stheraven typedef typename _Alloc::template rebind<__assoc_sub_state_alloc<_Alloc> >::other _A2; 1670227825Stheraven typedef __allocator_destructor<_A2> _D2; 1671227825Stheraven _A2 __a(__a0); 1672227825Stheraven unique_ptr<__assoc_sub_state_alloc<_Alloc>, _D2> __hold(__a.allocate(1), _D2(__a, 1)); 1673227825Stheraven ::new(__hold.get()) __assoc_sub_state_alloc<_Alloc>(__a0); 1674227825Stheraven __state_ = __hold.release(); 1675227825Stheraven} 1676227825Stheraven 1677227825Stheraventemplate <class _R> 1678227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1679227825Stheravenvoid 1680227825Stheravenswap(promise<_R>& __x, promise<_R>& __y) 1681227825Stheraven{ 1682227825Stheraven __x.swap(__y); 1683227825Stheraven} 1684227825Stheraven 1685227825Stheraventemplate <class _R, class _Alloc> 1686227825Stheraven struct _LIBCPP_VISIBLE uses_allocator<promise<_R>, _Alloc> 1687227825Stheraven : public true_type {}; 1688227825Stheraven 1689227825Stheraven#ifndef _LIBCPP_HAS_NO_VARIADICS 1690227825Stheraven 1691227825Stheraven// packaged_task 1692227825Stheraven 1693227825Stheraventemplate<class _Fp> class __packaged_task_base; 1694227825Stheraven 1695227825Stheraventemplate<class _R, class ..._ArgTypes> 1696227825Stheravenclass __packaged_task_base<_R(_ArgTypes...)> 1697227825Stheraven{ 1698227825Stheraven __packaged_task_base(const __packaged_task_base&); 1699227825Stheraven __packaged_task_base& operator=(const __packaged_task_base&); 1700227825Stheravenpublic: 1701227825Stheraven _LIBCPP_INLINE_VISIBILITY 1702227825Stheraven __packaged_task_base() {} 1703227825Stheraven _LIBCPP_INLINE_VISIBILITY 1704227825Stheraven virtual ~__packaged_task_base() {} 1705227825Stheraven virtual void __move_to(__packaged_task_base*) = 0; 1706227825Stheraven virtual void destroy() = 0; 1707227825Stheraven virtual void destroy_deallocate() = 0; 1708227825Stheraven virtual _R operator()(_ArgTypes&& ...) = 0; 1709227825Stheraven}; 1710227825Stheraven 1711227825Stheraventemplate<class _FD, class _Alloc, class _FB> class __packaged_task_func; 1712227825Stheraven 1713227825Stheraventemplate<class _F, class _Alloc, class _R, class ..._ArgTypes> 1714227825Stheravenclass __packaged_task_func<_F, _Alloc, _R(_ArgTypes...)> 1715227825Stheraven : public __packaged_task_base<_R(_ArgTypes...)> 1716227825Stheraven{ 1717227825Stheraven __compressed_pair<_F, _Alloc> __f_; 1718227825Stheravenpublic: 1719227825Stheraven _LIBCPP_INLINE_VISIBILITY 1720227825Stheraven explicit __packaged_task_func(const _F& __f) : __f_(__f) {} 1721227825Stheraven _LIBCPP_INLINE_VISIBILITY 1722227825Stheraven explicit __packaged_task_func(_F&& __f) : __f_(_VSTD::move(__f)) {} 1723227825Stheraven _LIBCPP_INLINE_VISIBILITY 1724227825Stheraven __packaged_task_func(const _F& __f, const _Alloc& __a) 1725227825Stheraven : __f_(__f, __a) {} 1726227825Stheraven _LIBCPP_INLINE_VISIBILITY 1727227825Stheraven __packaged_task_func(_F&& __f, const _Alloc& __a) 1728227825Stheraven : __f_(_VSTD::move(__f), __a) {} 1729227825Stheraven virtual void __move_to(__packaged_task_base<_R(_ArgTypes...)>*); 1730227825Stheraven virtual void destroy(); 1731227825Stheraven virtual void destroy_deallocate(); 1732227825Stheraven virtual _R operator()(_ArgTypes&& ... __args); 1733227825Stheraven}; 1734227825Stheraven 1735227825Stheraventemplate<class _F, class _Alloc, class _R, class ..._ArgTypes> 1736227825Stheravenvoid 1737227825Stheraven__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::__move_to( 1738227825Stheraven __packaged_task_base<_R(_ArgTypes...)>* __p) 1739227825Stheraven{ 1740227825Stheraven ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second())); 1741227825Stheraven} 1742227825Stheraven 1743227825Stheraventemplate<class _F, class _Alloc, class _R, class ..._ArgTypes> 1744227825Stheravenvoid 1745227825Stheraven__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::destroy() 1746227825Stheraven{ 1747227825Stheraven __f_.~__compressed_pair<_F, _Alloc>(); 1748227825Stheraven} 1749227825Stheraven 1750227825Stheraventemplate<class _F, class _Alloc, class _R, class ..._ArgTypes> 1751227825Stheravenvoid 1752227825Stheraven__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::destroy_deallocate() 1753227825Stheraven{ 1754227825Stheraven typedef typename _Alloc::template rebind<__packaged_task_func>::other _A; 1755227825Stheraven _A __a(__f_.second()); 1756227825Stheraven __f_.~__compressed_pair<_F, _Alloc>(); 1757227825Stheraven __a.deallocate(this, 1); 1758227825Stheraven} 1759227825Stheraven 1760227825Stheraventemplate<class _F, class _Alloc, class _R, class ..._ArgTypes> 1761227825Stheraven_R 1762227825Stheraven__packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg) 1763227825Stheraven{ 1764227825Stheraven return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...); 1765227825Stheraven} 1766227825Stheraven 1767227825Stheraventemplate <class _Callable> class __packaged_task_function; 1768227825Stheraven 1769227825Stheraventemplate<class _R, class ..._ArgTypes> 1770227825Stheravenclass __packaged_task_function<_R(_ArgTypes...)> 1771227825Stheraven{ 1772227825Stheraven typedef __packaged_task_base<_R(_ArgTypes...)> __base; 1773227825Stheraven aligned_storage<3*sizeof(void*)>::type __buf_; 1774227825Stheraven __base* __f_; 1775227825Stheraven 1776227825Stheravenpublic: 1777227825Stheraven typedef _R result_type; 1778227825Stheraven 1779227825Stheraven // construct/copy/destroy: 1780227825Stheraven _LIBCPP_INLINE_VISIBILITY 1781227825Stheraven __packaged_task_function() : __f_(nullptr) {} 1782227825Stheraven template<class _F> 1783227825Stheraven __packaged_task_function(_F&& __f); 1784227825Stheraven template<class _F, class _Alloc> 1785227825Stheraven __packaged_task_function(allocator_arg_t, const _Alloc& __a, _F&& __f); 1786227825Stheraven 1787227825Stheraven __packaged_task_function(__packaged_task_function&&); 1788227825Stheraven __packaged_task_function& operator=(__packaged_task_function&&); 1789227825Stheraven 1790227825Stheraven __packaged_task_function(const __packaged_task_function&) = delete; 1791227825Stheraven __packaged_task_function& operator=(const __packaged_task_function&) = delete; 1792227825Stheraven 1793227825Stheraven ~__packaged_task_function(); 1794227825Stheraven 1795227825Stheraven void swap(__packaged_task_function&); 1796227825Stheraven 1797227825Stheraven _R operator()(_ArgTypes...) const; 1798227825Stheraven}; 1799227825Stheraven 1800227825Stheraventemplate<class _R, class ..._ArgTypes> 1801227825Stheraven__packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(__packaged_task_function&& __f) 1802227825Stheraven{ 1803227825Stheraven if (__f.__f_ == nullptr) 1804227825Stheraven __f_ = nullptr; 1805227825Stheraven else if (__f.__f_ == (__base*)&__f.__buf_) 1806227825Stheraven { 1807227825Stheraven __f_ = (__base*)&__buf_; 1808227825Stheraven __f.__f_->__move_to(__f_); 1809227825Stheraven } 1810227825Stheraven else 1811227825Stheraven { 1812227825Stheraven __f_ = __f.__f_; 1813227825Stheraven __f.__f_ = nullptr; 1814227825Stheraven } 1815227825Stheraven} 1816227825Stheraven 1817227825Stheraventemplate<class _R, class ..._ArgTypes> 1818227825Stheraventemplate <class _F> 1819227825Stheraven__packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(_F&& __f) 1820227825Stheraven : __f_(nullptr) 1821227825Stheraven{ 1822227825Stheraven typedef typename remove_reference<_F>::type _FR; 1823227825Stheraven typedef __packaged_task_func<_FR, allocator<_FR>, _R(_ArgTypes...)> _FF; 1824227825Stheraven if (sizeof(_FF) <= sizeof(__buf_)) 1825227825Stheraven { 1826227825Stheraven __f_ = (__base*)&__buf_; 1827227825Stheraven ::new (__f_) _FF(_VSTD::forward<_F>(__f)); 1828227825Stheraven } 1829227825Stheraven else 1830227825Stheraven { 1831227825Stheraven typedef allocator<_FF> _A; 1832227825Stheraven _A __a; 1833227825Stheraven typedef __allocator_destructor<_A> _D; 1834227825Stheraven unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1)); 1835227825Stheraven ::new (__hold.get()) _FF(_VSTD::forward<_F>(__f), allocator<_FR>(__a)); 1836227825Stheraven __f_ = __hold.release(); 1837227825Stheraven } 1838227825Stheraven} 1839227825Stheraven 1840227825Stheraventemplate<class _R, class ..._ArgTypes> 1841227825Stheraventemplate <class _F, class _Alloc> 1842227825Stheraven__packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function( 1843227825Stheraven allocator_arg_t, const _Alloc& __a0, _F&& __f) 1844227825Stheraven : __f_(nullptr) 1845227825Stheraven{ 1846227825Stheraven typedef allocator_traits<_Alloc> __alloc_traits; 1847227825Stheraven typedef typename remove_reference<_F>::type _FR; 1848227825Stheraven typedef __packaged_task_func<_FR, _Alloc, _R(_ArgTypes...)> _FF; 1849227825Stheraven if (sizeof(_FF) <= sizeof(__buf_)) 1850227825Stheraven { 1851227825Stheraven __f_ = (__base*)&__buf_; 1852227825Stheraven ::new (__f_) _FF(_VSTD::forward<_F>(__f)); 1853227825Stheraven } 1854227825Stheraven else 1855227825Stheraven { 1856227825Stheraven typedef typename __alloc_traits::template 1857227825Stheraven#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES 1858227825Stheraven rebind_alloc<_FF> 1859227825Stheraven#else 1860227825Stheraven rebind_alloc<_FF>::other 1861227825Stheraven#endif 1862227825Stheraven _A; 1863227825Stheraven _A __a(__a0); 1864227825Stheraven typedef __allocator_destructor<_A> _D; 1865227825Stheraven unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1)); 1866227825Stheraven ::new (__hold.get()) _FF(_VSTD::forward<_F>(__f), _Alloc(__a)); 1867227825Stheraven __f_ = __hold.release(); 1868227825Stheraven } 1869227825Stheraven} 1870227825Stheraven 1871227825Stheraventemplate<class _R, class ..._ArgTypes> 1872227825Stheraven__packaged_task_function<_R(_ArgTypes...)>& 1873227825Stheraven__packaged_task_function<_R(_ArgTypes...)>::operator=(__packaged_task_function&& __f) 1874227825Stheraven{ 1875227825Stheraven if (__f_ == (__base*)&__buf_) 1876227825Stheraven __f_->destroy(); 1877227825Stheraven else if (__f_) 1878227825Stheraven __f_->destroy_deallocate(); 1879227825Stheraven __f_ = nullptr; 1880227825Stheraven if (__f.__f_ == nullptr) 1881227825Stheraven __f_ = nullptr; 1882227825Stheraven else if (__f.__f_ == (__base*)&__f.__buf_) 1883227825Stheraven { 1884227825Stheraven __f_ = (__base*)&__buf_; 1885227825Stheraven __f.__f_->__move_to(__f_); 1886227825Stheraven } 1887227825Stheraven else 1888227825Stheraven { 1889227825Stheraven __f_ = __f.__f_; 1890227825Stheraven __f.__f_ = nullptr; 1891227825Stheraven } 1892227825Stheraven} 1893227825Stheraven 1894227825Stheraventemplate<class _R, class ..._ArgTypes> 1895227825Stheraven__packaged_task_function<_R(_ArgTypes...)>::~__packaged_task_function() 1896227825Stheraven{ 1897227825Stheraven if (__f_ == (__base*)&__buf_) 1898227825Stheraven __f_->destroy(); 1899227825Stheraven else if (__f_) 1900227825Stheraven __f_->destroy_deallocate(); 1901227825Stheraven} 1902227825Stheraven 1903227825Stheraventemplate<class _R, class ..._ArgTypes> 1904227825Stheravenvoid 1905227825Stheraven__packaged_task_function<_R(_ArgTypes...)>::swap(__packaged_task_function& __f) 1906227825Stheraven{ 1907227825Stheraven if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_) 1908227825Stheraven { 1909227825Stheraven typename aligned_storage<sizeof(__buf_)>::type __tempbuf; 1910227825Stheraven __base* __t = (__base*)&__tempbuf; 1911227825Stheraven __f_->__move_to(__t); 1912227825Stheraven __f_->destroy(); 1913227825Stheraven __f_ = nullptr; 1914227825Stheraven __f.__f_->__move_to((__base*)&__buf_); 1915227825Stheraven __f.__f_->destroy(); 1916227825Stheraven __f.__f_ = nullptr; 1917227825Stheraven __f_ = (__base*)&__buf_; 1918227825Stheraven __t->__move_to((__base*)&__f.__buf_); 1919227825Stheraven __t->destroy(); 1920227825Stheraven __f.__f_ = (__base*)&__f.__buf_; 1921227825Stheraven } 1922227825Stheraven else if (__f_ == (__base*)&__buf_) 1923227825Stheraven { 1924227825Stheraven __f_->__move_to((__base*)&__f.__buf_); 1925227825Stheraven __f_->destroy(); 1926227825Stheraven __f_ = __f.__f_; 1927227825Stheraven __f.__f_ = (__base*)&__f.__buf_; 1928227825Stheraven } 1929227825Stheraven else if (__f.__f_ == (__base*)&__f.__buf_) 1930227825Stheraven { 1931227825Stheraven __f.__f_->__move_to((__base*)&__buf_); 1932227825Stheraven __f.__f_->destroy(); 1933227825Stheraven __f.__f_ = __f_; 1934227825Stheraven __f_ = (__base*)&__buf_; 1935227825Stheraven } 1936227825Stheraven else 1937227825Stheraven _VSTD::swap(__f_, __f.__f_); 1938227825Stheraven} 1939227825Stheraven 1940227825Stheraventemplate<class _R, class ..._ArgTypes> 1941227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 1942227825Stheraven_R 1943227825Stheraven__packaged_task_function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const 1944227825Stheraven{ 1945227825Stheraven return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...); 1946227825Stheraven} 1947227825Stheraven 1948227825Stheraventemplate<class _R, class ..._ArgTypes> 1949227825Stheravenclass _LIBCPP_VISIBLE packaged_task<_R(_ArgTypes...)> 1950227825Stheraven{ 1951227825Stheravenpublic: 1952227825Stheraven typedef _R result_type; 1953227825Stheraven 1954227825Stheravenprivate: 1955227825Stheraven __packaged_task_function<result_type(_ArgTypes...)> __f_; 1956227825Stheraven promise<result_type> __p_; 1957227825Stheraven 1958227825Stheravenpublic: 1959227825Stheraven // construction and destruction 1960227825Stheraven _LIBCPP_INLINE_VISIBILITY 1961227825Stheraven packaged_task() : __p_(nullptr) {} 1962227825Stheraven template <class _F> 1963227825Stheraven _LIBCPP_INLINE_VISIBILITY 1964227825Stheraven explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {} 1965227825Stheraven template <class _F, class _Allocator> 1966227825Stheraven _LIBCPP_INLINE_VISIBILITY 1967227825Stheraven explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f) 1968227825Stheraven : __f_(allocator_arg, __a, _VSTD::forward<_F>(__f)), 1969227825Stheraven __p_(allocator_arg, __a) {} 1970227825Stheraven // ~packaged_task() = default; 1971227825Stheraven 1972227825Stheraven // no copy 1973227825Stheraven packaged_task(packaged_task&) = delete; 1974227825Stheraven packaged_task& operator=(packaged_task&) = delete; 1975227825Stheraven 1976227825Stheraven // move support 1977227825Stheraven _LIBCPP_INLINE_VISIBILITY 1978227825Stheraven packaged_task(packaged_task&& __other) 1979227825Stheraven : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {} 1980227825Stheraven _LIBCPP_INLINE_VISIBILITY 1981227825Stheraven packaged_task& operator=(packaged_task&& __other) 1982227825Stheraven { 1983227825Stheraven __f_ = _VSTD::move(__other.__f_); 1984227825Stheraven __p_ = _VSTD::move(__other.__p_); 1985227825Stheraven return *this; 1986227825Stheraven } 1987227825Stheraven _LIBCPP_INLINE_VISIBILITY 1988227825Stheraven void swap(packaged_task& __other) 1989227825Stheraven { 1990227825Stheraven __f_.swap(__other.__f_); 1991227825Stheraven __p_.swap(__other.__p_); 1992227825Stheraven } 1993227825Stheraven 1994227825Stheraven _LIBCPP_INLINE_VISIBILITY 1995227825Stheraven bool valid() const {return __p_.__state_ != nullptr;} 1996227825Stheraven 1997227825Stheraven // result retrieval 1998227825Stheraven _LIBCPP_INLINE_VISIBILITY 1999227825Stheraven future<result_type> get_future() {return __p_.get_future();} 2000227825Stheraven 2001227825Stheraven // execution 2002227825Stheraven void operator()(_ArgTypes... __args); 2003227825Stheraven void make_ready_at_thread_exit(_ArgTypes... __args); 2004227825Stheraven 2005227825Stheraven void reset(); 2006227825Stheraven}; 2007227825Stheraven 2008227825Stheraventemplate<class _R, class ..._ArgTypes> 2009227825Stheravenvoid 2010227825Stheravenpackaged_task<_R(_ArgTypes...)>::operator()(_ArgTypes... __args) 2011227825Stheraven{ 2012227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2013227825Stheraven if (__p_.__state_ == nullptr) 2014227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2015227825Stheraven if (__p_.__state_->__has_value()) 2016227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 2017227825Stheraven try 2018227825Stheraven { 2019227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2020227825Stheraven __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...)); 2021227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2022227825Stheraven } 2023227825Stheraven catch (...) 2024227825Stheraven { 2025227825Stheraven __p_.set_exception(current_exception()); 2026227825Stheraven } 2027227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2028227825Stheraven} 2029227825Stheraven 2030227825Stheraventemplate<class _R, class ..._ArgTypes> 2031227825Stheravenvoid 2032227825Stheravenpackaged_task<_R(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) 2033227825Stheraven{ 2034227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2035227825Stheraven if (__p_.__state_ == nullptr) 2036227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2037227825Stheraven if (__p_.__state_->__has_value()) 2038227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 2039227825Stheraven try 2040227825Stheraven { 2041227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2042227825Stheraven __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...)); 2043227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2044227825Stheraven } 2045227825Stheraven catch (...) 2046227825Stheraven { 2047227825Stheraven __p_.set_exception_at_thread_exit(current_exception()); 2048227825Stheraven } 2049227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2050227825Stheraven} 2051227825Stheraven 2052227825Stheraventemplate<class _R, class ..._ArgTypes> 2053227825Stheravenvoid 2054227825Stheravenpackaged_task<_R(_ArgTypes...)>::reset() 2055227825Stheraven{ 2056227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2057227825Stheraven if (!valid()) 2058227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2059227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2060227825Stheraven __p_ = promise<result_type>(); 2061227825Stheraven} 2062227825Stheraven 2063227825Stheraventemplate<class ..._ArgTypes> 2064227825Stheravenclass _LIBCPP_VISIBLE packaged_task<void(_ArgTypes...)> 2065227825Stheraven{ 2066227825Stheravenpublic: 2067227825Stheraven typedef void result_type; 2068227825Stheraven 2069227825Stheravenprivate: 2070227825Stheraven __packaged_task_function<result_type(_ArgTypes...)> __f_; 2071227825Stheraven promise<result_type> __p_; 2072227825Stheraven 2073227825Stheravenpublic: 2074227825Stheraven // construction and destruction 2075227825Stheraven _LIBCPP_INLINE_VISIBILITY 2076227825Stheraven packaged_task() : __p_(nullptr) {} 2077227825Stheraven template <class _F> 2078227825Stheraven _LIBCPP_INLINE_VISIBILITY 2079227825Stheraven explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {} 2080227825Stheraven template <class _F, class _Allocator> 2081227825Stheraven _LIBCPP_INLINE_VISIBILITY 2082227825Stheraven explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f) 2083227825Stheraven : __f_(allocator_arg, __a, _VSTD::forward<_F>(__f)), 2084227825Stheraven __p_(allocator_arg, __a) {} 2085227825Stheraven // ~packaged_task() = default; 2086227825Stheraven 2087227825Stheraven // no copy 2088227825Stheraven packaged_task(packaged_task&) = delete; 2089227825Stheraven packaged_task& operator=(packaged_task&) = delete; 2090227825Stheraven 2091227825Stheraven // move support 2092227825Stheraven _LIBCPP_INLINE_VISIBILITY 2093227825Stheraven packaged_task(packaged_task&& __other) 2094227825Stheraven : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {} 2095227825Stheraven _LIBCPP_INLINE_VISIBILITY 2096227825Stheraven packaged_task& operator=(packaged_task&& __other) 2097227825Stheraven { 2098227825Stheraven __f_ = _VSTD::move(__other.__f_); 2099227825Stheraven __p_ = _VSTD::move(__other.__p_); 2100227825Stheraven return *this; 2101227825Stheraven } 2102227825Stheraven _LIBCPP_INLINE_VISIBILITY 2103227825Stheraven void swap(packaged_task& __other) 2104227825Stheraven { 2105227825Stheraven __f_.swap(__other.__f_); 2106227825Stheraven __p_.swap(__other.__p_); 2107227825Stheraven } 2108227825Stheraven 2109227825Stheraven _LIBCPP_INLINE_VISIBILITY 2110227825Stheraven bool valid() const {return __p_.__state_ != nullptr;} 2111227825Stheraven 2112227825Stheraven // result retrieval 2113227825Stheraven _LIBCPP_INLINE_VISIBILITY 2114227825Stheraven future<result_type> get_future() {return __p_.get_future();} 2115227825Stheraven 2116227825Stheraven // execution 2117227825Stheraven void operator()(_ArgTypes... __args); 2118227825Stheraven void make_ready_at_thread_exit(_ArgTypes... __args); 2119227825Stheraven 2120227825Stheraven void reset(); 2121227825Stheraven}; 2122227825Stheraven 2123227825Stheraventemplate<class ..._ArgTypes> 2124227825Stheravenvoid 2125227825Stheravenpackaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args) 2126227825Stheraven{ 2127227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2128227825Stheraven if (__p_.__state_ == nullptr) 2129227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2130227825Stheraven if (__p_.__state_->__has_value()) 2131227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 2132227825Stheraven try 2133227825Stheraven { 2134227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2135227825Stheraven __f_(_VSTD::forward<_ArgTypes>(__args)...); 2136227825Stheraven __p_.set_value(); 2137227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2138227825Stheraven } 2139227825Stheraven catch (...) 2140227825Stheraven { 2141227825Stheraven __p_.set_exception(current_exception()); 2142227825Stheraven } 2143227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2144227825Stheraven} 2145227825Stheraven 2146227825Stheraventemplate<class ..._ArgTypes> 2147227825Stheravenvoid 2148227825Stheravenpackaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) 2149227825Stheraven{ 2150227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2151227825Stheraven if (__p_.__state_ == nullptr) 2152227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2153227825Stheraven if (__p_.__state_->__has_value()) 2154227825Stheraven throw future_error(make_error_code(future_errc::promise_already_satisfied)); 2155227825Stheraven try 2156227825Stheraven { 2157227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2158227825Stheraven __f_(_VSTD::forward<_ArgTypes>(__args)...); 2159227825Stheraven __p_.set_value_at_thread_exit(); 2160227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2161227825Stheraven } 2162227825Stheraven catch (...) 2163227825Stheraven { 2164227825Stheraven __p_.set_exception_at_thread_exit(current_exception()); 2165227825Stheraven } 2166227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2167227825Stheraven} 2168227825Stheraven 2169227825Stheraventemplate<class ..._ArgTypes> 2170227825Stheravenvoid 2171227825Stheravenpackaged_task<void(_ArgTypes...)>::reset() 2172227825Stheraven{ 2173227825Stheraven#ifndef _LIBCPP_NO_EXCEPTIONS 2174227825Stheraven if (!valid()) 2175227825Stheraven throw future_error(make_error_code(future_errc::no_state)); 2176227825Stheraven#endif // _LIBCPP_NO_EXCEPTIONS 2177227825Stheraven __p_ = promise<result_type>(); 2178227825Stheraven} 2179227825Stheraven 2180227825Stheraventemplate <class _Callable> 2181227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2182227825Stheravenvoid 2183227825Stheravenswap(packaged_task<_Callable>& __x, packaged_task<_Callable>& __y) 2184227825Stheraven{ 2185227825Stheraven __x.swap(__y); 2186227825Stheraven} 2187227825Stheraven 2188227825Stheraventemplate <class _Callable, class _Alloc> 2189227825Stheravenstruct _LIBCPP_VISIBLE uses_allocator<packaged_task<_Callable>, _Alloc> 2190227825Stheraven : public true_type {}; 2191227825Stheraven 2192227825Stheraventemplate <class _R, class _F> 2193227825Stheravenfuture<_R> 2194227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2195227825Stheraven__make_deferred_assoc_state(_F&& __f) 2196227825Stheraven#else 2197227825Stheraven__make_deferred_assoc_state(_F __f) 2198227825Stheraven#endif 2199227825Stheraven{ 2200227825Stheraven unique_ptr<__deferred_assoc_state<_R, _F>, __release_shared_count> 2201227825Stheraven __h(new __deferred_assoc_state<_R, _F>(_VSTD::forward<_F>(__f))); 2202227825Stheraven return future<_R>(__h.get()); 2203227825Stheraven} 2204227825Stheraven 2205227825Stheraventemplate <class _R, class _F> 2206227825Stheravenfuture<_R> 2207227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2208227825Stheraven__make_async_assoc_state(_F&& __f) 2209227825Stheraven#else 2210227825Stheraven__make_async_assoc_state(_F __f) 2211227825Stheraven#endif 2212227825Stheraven{ 2213227825Stheraven unique_ptr<__async_assoc_state<_R, _F>, __release_shared_count> 2214227825Stheraven __h(new __async_assoc_state<_R, _F>(_VSTD::forward<_F>(__f))); 2215227825Stheraven _VSTD::thread(&__async_assoc_state<_R, _F>::__execute, __h.get()).detach(); 2216227825Stheraven return future<_R>(__h.get()); 2217227825Stheraven} 2218227825Stheraven 2219227825Stheraventemplate <class _F, class... _Args> 2220227825Stheravenclass __async_func 2221227825Stheraven{ 2222227825Stheraven tuple<_F, _Args...> __f_; 2223227825Stheraven 2224227825Stheravenpublic: 2225227825Stheraven typedef typename __invoke_of<_F, _Args...>::type _R; 2226227825Stheraven 2227227825Stheraven _LIBCPP_INLINE_VISIBILITY 2228227825Stheraven explicit __async_func(_F&& __f, _Args&&... __args) 2229227825Stheraven : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {} 2230227825Stheraven 2231227825Stheraven _LIBCPP_INLINE_VISIBILITY 2232227825Stheraven __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {} 2233227825Stheraven 2234227825Stheraven _R operator()() 2235227825Stheraven { 2236227825Stheraven typedef typename __make_tuple_indices<1+sizeof...(_Args), 1>::type _Index; 2237227825Stheraven return __execute(_Index()); 2238227825Stheraven } 2239227825Stheravenprivate: 2240227825Stheraven template <size_t ..._Indices> 2241227825Stheraven _R 2242227825Stheraven __execute(__tuple_indices<_Indices...>) 2243227825Stheraven { 2244227825Stheraven return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...); 2245227825Stheraven } 2246227825Stheraven}; 2247227825Stheraven 2248227825Stheraventemplate <class _F, class... _Args> 2249227825Stheravenfuture<typename __invoke_of<typename decay<_F>::type, typename decay<_Args>::type...>::type> 2250227825Stheravenasync(launch __policy, _F&& __f, _Args&&... __args) 2251227825Stheraven{ 2252227825Stheraven typedef __async_func<typename decay<_F>::type, typename decay<_Args>::type...> _BF; 2253227825Stheraven typedef typename _BF::_R _R; 2254227825Stheraven future<_R> __r; 2255227825Stheraven if (__policy & launch::async) 2256227825Stheraven __r = _VSTD::__make_async_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)), 2257227825Stheraven __decay_copy(_VSTD::forward<_Args>(__args))...)); 2258227825Stheraven else if (__policy & launch::deferred) 2259227825Stheraven __r = _VSTD::__make_deferred_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)), 2260227825Stheraven __decay_copy(_VSTD::forward<_Args>(__args))...)); 2261227825Stheraven return __r; 2262227825Stheraven} 2263227825Stheraven 2264227825Stheraventemplate <class _F, class... _Args> 2265227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2266227825Stheravenfuture<typename __invoke_of<typename decay<_F>::type, typename decay<_Args>::type...>::type> 2267227825Stheravenasync(_F&& __f, _Args&&... __args) 2268227825Stheraven{ 2269227825Stheraven return _VSTD::async(launch::any, _VSTD::forward<_F>(__f), 2270227825Stheraven _VSTD::forward<_Args>(__args)...); 2271227825Stheraven} 2272227825Stheraven 2273227825Stheraven#endif // _LIBCPP_HAS_NO_VARIADICS 2274227825Stheraven 2275227825Stheraven// shared_future 2276227825Stheraven 2277227825Stheraventemplate <class _R> 2278227825Stheravenclass _LIBCPP_VISIBLE shared_future 2279227825Stheraven{ 2280227825Stheraven __assoc_state<_R>* __state_; 2281227825Stheraven 2282227825Stheravenpublic: 2283227825Stheraven _LIBCPP_INLINE_VISIBILITY 2284227825Stheraven shared_future() : __state_(nullptr) {} 2285227825Stheraven _LIBCPP_INLINE_VISIBILITY 2286227825Stheraven shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) 2287227825Stheraven {if (__state_) __state_->__add_shared();} 2288227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2289227825Stheraven _LIBCPP_INLINE_VISIBILITY 2290227825Stheraven shared_future(future<_R>&& __f) : __state_(__f.__state_) 2291227825Stheraven {__f.__state_ = nullptr;} 2292227825Stheraven _LIBCPP_INLINE_VISIBILITY 2293227825Stheraven shared_future(shared_future&& __rhs) : __state_(__rhs.__state_) 2294227825Stheraven {__rhs.__state_ = nullptr;} 2295227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2296227825Stheraven ~shared_future(); 2297227825Stheraven shared_future& operator=(const shared_future& __rhs); 2298227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2299227825Stheraven _LIBCPP_INLINE_VISIBILITY 2300227825Stheraven shared_future& operator=(shared_future&& __rhs) 2301227825Stheraven { 2302227825Stheraven shared_future(std::move(__rhs)).swap(*this); 2303227825Stheraven return *this; 2304227825Stheraven } 2305227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2306227825Stheraven 2307227825Stheraven // retrieving the value 2308227825Stheraven _LIBCPP_INLINE_VISIBILITY 2309227825Stheraven const _R& get() const {return __state_->copy();} 2310227825Stheraven 2311227825Stheraven _LIBCPP_INLINE_VISIBILITY 2312227825Stheraven void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 2313227825Stheraven 2314227825Stheraven // functions to check state 2315227825Stheraven _LIBCPP_INLINE_VISIBILITY 2316227825Stheraven bool valid() const {return __state_ != nullptr;} 2317227825Stheraven 2318227825Stheraven _LIBCPP_INLINE_VISIBILITY 2319227825Stheraven void wait() const {__state_->wait();} 2320227825Stheraven template <class _Rep, class _Period> 2321227825Stheraven _LIBCPP_INLINE_VISIBILITY 2322227825Stheraven future_status 2323227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 2324227825Stheraven {return __state_->wait_for(__rel_time);} 2325227825Stheraven template <class _Clock, class _Duration> 2326227825Stheraven _LIBCPP_INLINE_VISIBILITY 2327227825Stheraven future_status 2328227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 2329227825Stheraven {return __state_->wait_until(__abs_time);} 2330227825Stheraven}; 2331227825Stheraven 2332227825Stheraventemplate <class _R> 2333227825Stheravenshared_future<_R>::~shared_future() 2334227825Stheraven{ 2335227825Stheraven if (__state_) 2336227825Stheraven __state_->__release_shared(); 2337227825Stheraven} 2338227825Stheraven 2339227825Stheraventemplate <class _R> 2340227825Stheravenshared_future<_R>& 2341227825Stheravenshared_future<_R>::operator=(const shared_future& __rhs) 2342227825Stheraven{ 2343227825Stheraven if (__rhs.__state_) 2344227825Stheraven __rhs.__state_->__add_shared(); 2345227825Stheraven if (__state_) 2346227825Stheraven __state_->__release_shared(); 2347227825Stheraven __state_ = __rhs.__state_; 2348227825Stheraven return *this; 2349227825Stheraven} 2350227825Stheraven 2351227825Stheraventemplate <class _R> 2352227825Stheravenclass _LIBCPP_VISIBLE shared_future<_R&> 2353227825Stheraven{ 2354227825Stheraven __assoc_state<_R&>* __state_; 2355227825Stheraven 2356227825Stheravenpublic: 2357227825Stheraven _LIBCPP_INLINE_VISIBILITY 2358227825Stheraven shared_future() : __state_(nullptr) {} 2359227825Stheraven _LIBCPP_INLINE_VISIBILITY 2360227825Stheraven shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) 2361227825Stheraven {if (__state_) __state_->__add_shared();} 2362227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2363227825Stheraven _LIBCPP_INLINE_VISIBILITY 2364227825Stheraven shared_future(future<_R&>&& __f) : __state_(__f.__state_) 2365227825Stheraven {__f.__state_ = nullptr;} 2366227825Stheraven _LIBCPP_INLINE_VISIBILITY 2367227825Stheraven shared_future(shared_future&& __rhs) : __state_(__rhs.__state_) 2368227825Stheraven {__rhs.__state_ = nullptr;} 2369227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2370227825Stheraven ~shared_future(); 2371227825Stheraven shared_future& operator=(const shared_future& __rhs); 2372227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2373227825Stheraven _LIBCPP_INLINE_VISIBILITY 2374227825Stheraven shared_future& operator=(shared_future&& __rhs) 2375227825Stheraven { 2376227825Stheraven shared_future(std::move(__rhs)).swap(*this); 2377227825Stheraven return *this; 2378227825Stheraven } 2379227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2380227825Stheraven 2381227825Stheraven // retrieving the value 2382227825Stheraven _LIBCPP_INLINE_VISIBILITY 2383227825Stheraven _R& get() const {return __state_->copy();} 2384227825Stheraven 2385227825Stheraven _LIBCPP_INLINE_VISIBILITY 2386227825Stheraven void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 2387227825Stheraven 2388227825Stheraven // functions to check state 2389227825Stheraven _LIBCPP_INLINE_VISIBILITY 2390227825Stheraven bool valid() const {return __state_ != nullptr;} 2391227825Stheraven 2392227825Stheraven _LIBCPP_INLINE_VISIBILITY 2393227825Stheraven void wait() const {__state_->wait();} 2394227825Stheraven template <class _Rep, class _Period> 2395227825Stheraven _LIBCPP_INLINE_VISIBILITY 2396227825Stheraven future_status 2397227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 2398227825Stheraven {return __state_->wait_for(__rel_time);} 2399227825Stheraven template <class _Clock, class _Duration> 2400227825Stheraven _LIBCPP_INLINE_VISIBILITY 2401227825Stheraven future_status 2402227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 2403227825Stheraven {return __state_->wait_until(__abs_time);} 2404227825Stheraven}; 2405227825Stheraven 2406227825Stheraventemplate <class _R> 2407227825Stheravenshared_future<_R&>::~shared_future() 2408227825Stheraven{ 2409227825Stheraven if (__state_) 2410227825Stheraven __state_->__release_shared(); 2411227825Stheraven} 2412227825Stheraven 2413227825Stheraventemplate <class _R> 2414227825Stheravenshared_future<_R&>& 2415227825Stheravenshared_future<_R&>::operator=(const shared_future& __rhs) 2416227825Stheraven{ 2417227825Stheraven if (__rhs.__state_) 2418227825Stheraven __rhs.__state_->__add_shared(); 2419227825Stheraven if (__state_) 2420227825Stheraven __state_->__release_shared(); 2421227825Stheraven __state_ = __rhs.__state_; 2422227825Stheraven return *this; 2423227825Stheraven} 2424227825Stheraven 2425227825Stheraventemplate <> 2426227825Stheravenclass _LIBCPP_VISIBLE shared_future<void> 2427227825Stheraven{ 2428227825Stheraven __assoc_sub_state* __state_; 2429227825Stheraven 2430227825Stheravenpublic: 2431227825Stheraven _LIBCPP_INLINE_VISIBILITY 2432227825Stheraven shared_future() : __state_(nullptr) {} 2433227825Stheraven _LIBCPP_INLINE_VISIBILITY 2434227825Stheraven shared_future(const shared_future& __rhs) : __state_(__rhs.__state_) 2435227825Stheraven {if (__state_) __state_->__add_shared();} 2436227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2437227825Stheraven _LIBCPP_INLINE_VISIBILITY 2438227825Stheraven shared_future(future<void>&& __f) : __state_(__f.__state_) 2439227825Stheraven {__f.__state_ = nullptr;} 2440227825Stheraven _LIBCPP_INLINE_VISIBILITY 2441227825Stheraven shared_future(shared_future&& __rhs) : __state_(__rhs.__state_) 2442227825Stheraven {__rhs.__state_ = nullptr;} 2443227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2444227825Stheraven ~shared_future(); 2445227825Stheraven shared_future& operator=(const shared_future& __rhs); 2446227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2447227825Stheraven _LIBCPP_INLINE_VISIBILITY 2448227825Stheraven shared_future& operator=(shared_future&& __rhs) 2449227825Stheraven { 2450227825Stheraven shared_future(std::move(__rhs)).swap(*this); 2451227825Stheraven return *this; 2452227825Stheraven } 2453227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2454227825Stheraven 2455227825Stheraven // retrieving the value 2456227825Stheraven _LIBCPP_INLINE_VISIBILITY 2457227825Stheraven void get() const {__state_->copy();} 2458227825Stheraven 2459227825Stheraven _LIBCPP_INLINE_VISIBILITY 2460227825Stheraven void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);} 2461227825Stheraven 2462227825Stheraven // functions to check state 2463227825Stheraven _LIBCPP_INLINE_VISIBILITY 2464227825Stheraven bool valid() const {return __state_ != nullptr;} 2465227825Stheraven 2466227825Stheraven _LIBCPP_INLINE_VISIBILITY 2467227825Stheraven void wait() const {__state_->wait();} 2468227825Stheraven template <class _Rep, class _Period> 2469227825Stheraven _LIBCPP_INLINE_VISIBILITY 2470227825Stheraven future_status 2471227825Stheraven wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const 2472227825Stheraven {return __state_->wait_for(__rel_time);} 2473227825Stheraven template <class _Clock, class _Duration> 2474227825Stheraven _LIBCPP_INLINE_VISIBILITY 2475227825Stheraven future_status 2476227825Stheraven wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const 2477227825Stheraven {return __state_->wait_until(__abs_time);} 2478227825Stheraven}; 2479227825Stheraven 2480227825Stheraventemplate <class _R> 2481227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2482227825Stheravenvoid 2483227825Stheravenswap(shared_future<_R>& __x, shared_future<_R>& __y) 2484227825Stheraven{ 2485227825Stheraven __x.swap(__y); 2486227825Stheraven} 2487227825Stheraven 2488227825Stheraventemplate <class _R> 2489227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2490227825Stheravenshared_future<_R> 2491227825Stheravenfuture<_R>::share() 2492227825Stheraven{ 2493227825Stheraven return shared_future<_R>(_VSTD::move(*this)); 2494227825Stheraven} 2495227825Stheraven 2496227825Stheraventemplate <class _R> 2497227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2498227825Stheravenshared_future<_R&> 2499227825Stheravenfuture<_R&>::share() 2500227825Stheraven{ 2501227825Stheraven return shared_future<_R&>(_VSTD::move(*this)); 2502227825Stheraven} 2503227825Stheraven 2504227825Stheraven#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES 2505227825Stheraven 2506227825Stheraveninline _LIBCPP_INLINE_VISIBILITY 2507227825Stheravenshared_future<void> 2508227825Stheravenfuture<void>::share() 2509227825Stheraven{ 2510227825Stheraven return shared_future<void>(_VSTD::move(*this)); 2511227825Stheraven} 2512227825Stheraven 2513227825Stheraven#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES 2514227825Stheraven 2515227825Stheraven_LIBCPP_END_NAMESPACE_STD 2516227825Stheraven 2517227825Stheraven#endif // _LIBCPP_FUTURE 2518