00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029 #ifndef _GLIBCXX_FUTURE
00030 #define _GLIBCXX_FUTURE 1
00031
00032 #pragma GCC system_header
00033
00034 #ifndef __GXX_EXPERIMENTAL_CXX0X__
00035 # include <bits/c++0x_warning.h>
00036 #else
00037
00038 #include <functional>
00039 #include <memory>
00040 #include <mutex>
00041 #include <thread>
00042 #include <condition_variable>
00043 #include <system_error>
00044 #include <exception>
00045 #include <atomic>
00046 #include <bits/functexcept.h>
00047
00048 namespace std
00049 {
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059 enum class future_errc
00060 {
00061 broken_promise,
00062 future_already_retrieved,
00063 promise_already_satisfied,
00064 no_state
00065 };
00066
00067 template<>
00068 struct is_error_code_enum<future_errc> : public true_type { };
00069
00070
00071 extern const error_category* const future_category;
00072
00073
00074 inline error_code make_error_code(future_errc __errc)
00075 { return error_code(static_cast<int>(__errc), *future_category); }
00076
00077
00078 inline error_condition make_error_condition(future_errc __errc)
00079 { return error_condition(static_cast<int>(__errc), *future_category); }
00080
00081
00082
00083
00084
00085 class future_error : public logic_error
00086 {
00087 error_code _M_code;
00088
00089 public:
00090 explicit future_error(error_code __ec)
00091 : logic_error("std::future_error"), _M_code(__ec)
00092 { }
00093
00094 virtual ~future_error() throw();
00095
00096 virtual const char*
00097 what() const throw();
00098
00099 const error_code&
00100 code() const throw() { return _M_code; }
00101 };
00102
00103
00104 template<typename _Res>
00105 class future;
00106
00107 template<typename _Res>
00108 class shared_future;
00109
00110 template<typename _Res>
00111 class atomic_future;
00112
00113 template<typename _Signature>
00114 class packaged_task;
00115
00116 template<typename _Res>
00117 class promise;
00118
00119 enum class launch { any, async, sync };
00120
00121 template<typename _Fn, typename... _Args>
00122 future<typename result_of<_Fn(_Args...)>::type>
00123 async(launch __policy, _Fn&& __fn, _Args&&... __args);
00124
00125 template<typename _Fn, typename... _Args>
00126 typename
00127 enable_if<!is_same<typename decay<_Fn>::type, launch>::value,
00128 future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
00129 >::type
00130 async(_Fn&& __fn, _Args&&... __args);
00131
00132 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \
00133 && defined(_GLIBCXX_ATOMIC_BUILTINS_4)
00134
00135
00136 struct __future_base
00137 {
00138
00139 struct _Result_base
00140 {
00141 exception_ptr _M_error;
00142
00143 _Result_base() = default;
00144 _Result_base(const _Result_base&) = delete;
00145 _Result_base& operator=(const _Result_base&) = delete;
00146
00147
00148 virtual void _M_destroy() = 0;
00149
00150 struct _Deleter
00151 {
00152 void operator()(_Result_base* __fr) const { __fr->_M_destroy(); }
00153 };
00154
00155 protected:
00156 ~_Result_base();
00157 };
00158
00159
00160 template<typename _Res>
00161 struct _Result : _Result_base
00162 {
00163 private:
00164 typedef alignment_of<_Res> __a_of;
00165 typedef aligned_storage<sizeof(_Res), __a_of::value> __align_storage;
00166 typedef typename __align_storage::type __align_type;
00167
00168 __align_type _M_storage;
00169 bool _M_initialized;
00170
00171 public:
00172 _Result() : _M_initialized() { }
00173
00174 ~_Result()
00175 {
00176 if (_M_initialized)
00177 _M_value().~_Res();
00178 }
00179
00180
00181 _Res&
00182 _M_value() { return *static_cast<_Res*>(_M_addr()); }
00183
00184 void
00185 _M_set(const _Res& __res)
00186 {
00187 ::new (_M_addr()) _Res(__res);
00188 _M_initialized = true;
00189 }
00190
00191 void
00192 _M_set(_Res&& __res)
00193 {
00194 ::new (_M_addr()) _Res(std::move(__res));
00195 _M_initialized = true;
00196 }
00197
00198 private:
00199 void _M_destroy() { delete this; }
00200
00201 void* _M_addr() { return static_cast<void*>(&_M_storage); }
00202 };
00203
00204
00205
00206
00207
00208
00209
00210 template<typename _Res>
00211 struct _Ptr
00212 {
00213 typedef unique_ptr<_Res, _Result_base::_Deleter> type;
00214 };
00215
00216
00217
00218
00219 template<typename _Res, typename _Alloc>
00220 struct _Result_alloc : _Result<_Res>
00221 {
00222 typedef typename _Alloc::template rebind<_Result_alloc>::other
00223 __allocator_type;
00224
00225 explicit
00226 _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _M_alloc(__a)
00227 { }
00228
00229 private:
00230 void _M_destroy()
00231 {
00232 __allocator_type __a(_M_alloc);
00233 __a.destroy(this);
00234 __a.deallocate(this, 1);
00235 }
00236
00237 __allocator_type _M_alloc;
00238 };
00239
00240 template<typename _Res, typename _Allocator>
00241 static typename _Ptr<_Result_alloc<_Res, _Allocator>>::type
00242 _S_allocate_result(const _Allocator& __a)
00243 {
00244 typedef _Result_alloc<_Res, _Allocator> __result_type;
00245 typename __result_type::__allocator_type __a2(__a);
00246 __result_type* __p = __a2.allocate(1);
00247 __try
00248 {
00249 __a2.construct(__p, __a);
00250 }
00251 __catch(...)
00252 {
00253 __a2.deallocate(__p, 1);
00254 __throw_exception_again;
00255 }
00256 return typename _Ptr<__result_type>::type(__p);
00257 }
00258 */
00259
00260
00261
00262 class _State
00263 {
00264 typedef _Ptr<_Result_base>::type _Ptr_type;
00265
00266 _Ptr_type _M_result;
00267 mutex _M_mutex;
00268 condition_variable _M_cond;
00269 atomic_flag _M_retrieved;
00270 once_flag _M_once;
00271
00272 public:
00273 _State() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { }
00274
00275 _State(const _State&) = delete;
00276 _State& operator=(const _State&) = delete;
00277
00278 _Result_base&
00279 wait()
00280 {
00281 _M_run_deferred();
00282 unique_lock<mutex> __lock(_M_mutex);
00283 if (!_M_ready())
00284 _M_cond.wait(__lock, std::bind<bool>(&_State::_M_ready, this));
00285 return *_M_result;
00286 }
00287
00288 template<typename _Rep, typename _Period>
00289 bool
00290 wait_for(const chrono::duration<_Rep, _Period>& __rel)
00291 {
00292 unique_lock<mutex> __lock(_M_mutex);
00293 auto __bound = std::bind<bool>(&_State::_M_ready, this);
00294 return _M_ready() || _M_cond.wait_for(__lock, __rel, __bound);
00295 }
00296
00297 template<typename _Clock, typename _Duration>
00298 bool
00299 wait_until(const chrono::time_point<_Clock, _Duration>& __abs)
00300 {
00301 unique_lock<mutex> __lock(_M_mutex);
00302 auto __bound = std::bind<bool>(&_State::_M_ready, this);
00303 return _M_ready() || _M_cond.wait_until(__lock, __abs, __bound);
00304 }
00305
00306 void
00307 _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
00308 {
00309 bool __set = __ignore_failure;
00310
00311
00312 call_once(_M_once, mem_fn(&_State::_M_do_set), this, ref(__res),
00313 ref(__set));
00314 if (!__set)
00315 __throw_future_error(int(future_errc::promise_already_satisfied));
00316 }
00317
00318 void
00319 _M_break_promise(_Ptr_type __res)
00320 {
00321 if (static_cast<bool>(__res))
00322 {
00323 error_code __ec(make_error_code(future_errc::broken_promise));
00324 __res->_M_error = copy_exception(future_error(__ec));
00325 {
00326 lock_guard<mutex> __lock(_M_mutex);
00327 _M_result.swap(__res);
00328 }
00329 _M_cond.notify_all();
00330 }
00331 }
00332
00333
00334 void
00335 _M_set_retrieved_flag()
00336 {
00337 if (_M_retrieved.test_and_set())
00338 __throw_future_error(int(future_errc::future_already_retrieved));
00339 }
00340
00341 template<typename _Res, typename _Arg>
00342 struct _Setter;
00343
00344
00345 template<typename _Res, typename _Arg>
00346 struct _Setter<_Res, _Arg&>
00347 {
00348
00349
00350 static_assert(is_same<_Res, _Arg&>::value
00351 || is_same<const _Res, _Arg>::value,
00352 "Invalid specialisation");
00353
00354 typename promise<_Res>::_Ptr_type operator()()
00355 {
00356 _State::_S_check(_M_promise->_M_future);
00357 _M_promise->_M_storage->_M_set(_M_arg);
00358 return std::move(_M_promise->_M_storage);
00359 }
00360 promise<_Res>* _M_promise;
00361 _Arg& _M_arg;
00362 };
00363
00364
00365 template<typename _Res>
00366 struct _Setter<_Res, _Res&&>
00367 {
00368 typename promise<_Res>::_Ptr_type operator()()
00369 {
00370 _State::_S_check(_M_promise->_M_future);
00371 _M_promise->_M_storage->_M_set(std::move(_M_arg));
00372 return std::move(_M_promise->_M_storage);
00373 }
00374 promise<_Res>* _M_promise;
00375 _Res& _M_arg;
00376 };
00377
00378 struct __exception_ptr_tag { };
00379
00380
00381 template<typename _Res>
00382 struct _Setter<_Res, __exception_ptr_tag>
00383 {
00384 typename promise<_Res>::_Ptr_type operator()()
00385 {
00386 _State::_S_check(_M_promise->_M_future);
00387 _M_promise->_M_storage->_M_error = _M_ex;
00388 return std::move(_M_promise->_M_storage);
00389 }
00390
00391 promise<_Res>* _M_promise;
00392 exception_ptr& _M_ex;
00393 };
00394
00395 template<typename _Res, typename _Arg>
00396 static _Setter<_Res, _Arg&&>
00397 __setter(promise<_Res>* __prom, _Arg&& __arg)
00398 {
00399 return _Setter<_Res, _Arg&&>{ __prom, __arg };
00400 }
00401
00402 template<typename _Res>
00403 static _Setter<_Res, __exception_ptr_tag>
00404 __setter(exception_ptr& __ex, promise<_Res>* __prom)
00405 {
00406 return _Setter<_Res, __exception_ptr_tag>{ __prom, __ex };
00407 }
00408
00409 static _Setter<void, void>
00410 __setter(promise<void>* __prom);
00411
00412 template<typename _Tp>
00413 static bool
00414 _S_check(const shared_ptr<_Tp>& __p)
00415 {
00416 if (!static_cast<bool>(__p))
00417 __throw_future_error((int)future_errc::no_state);
00418 }
00419
00420 private:
00421 void
00422 _M_do_set(function<_Ptr_type()>& __f, bool& __set)
00423 {
00424 _Ptr_type __res = __f();
00425 {
00426 lock_guard<mutex> __lock(_M_mutex);
00427 _M_result.swap(__res);
00428 }
00429 _M_cond.notify_all();
00430 __set = true;
00431 }
00432
00433 bool _M_ready() const { return static_cast<bool>(_M_result); }
00434
00435 virtual void _M_run_deferred() { }
00436 };
00437
00438 template<typename _Res>
00439 class _Deferred_state;
00440
00441 template<typename _Res>
00442 class _Async_state;
00443
00444 template<typename _Signature>
00445 class _Task_state;
00446
00447 template<typename _StateT, typename _Res = typename _StateT::_Res_type>
00448 struct _Task_setter;
00449 };
00450
00451 inline __future_base::_Result_base::~_Result_base() = default;
00452
00453
00454 template<typename _Res>
00455 struct __future_base::_Result<_Res&> : __future_base::_Result_base
00456 {
00457 _Result() : _M_value_ptr() { }
00458
00459 void _M_set(_Res& __res) { _M_value_ptr = &__res; }
00460
00461 _Res& _M_get() { return *_M_value_ptr; }
00462
00463 private:
00464 _Res* _M_value_ptr;
00465
00466 void _M_destroy() { delete this; }
00467 };
00468
00469
00470 template<>
00471 struct __future_base::_Result<void> : __future_base::_Result_base
00472 {
00473 private:
00474 void _M_destroy() { delete this; }
00475 };
00476
00477
00478
00479 template<typename _Res>
00480 class __basic_future : public __future_base
00481 {
00482 protected:
00483 typedef shared_ptr<_State> __state_type;
00484 typedef __future_base::_Result<_Res>& __result_type;
00485
00486 private:
00487 __state_type _M_state;
00488
00489 public:
00490
00491 __basic_future(const __basic_future&) = delete;
00492 __basic_future& operator=(const __basic_future&) = delete;
00493
00494 bool
00495 valid() const { return static_cast<bool>(_M_state); }
00496
00497 void
00498 wait() const { _M_state->wait(); }
00499
00500 template<typename _Rep, typename _Period>
00501 bool
00502 wait_for(const chrono::duration<_Rep, _Period>& __rel) const
00503 { return _M_state->wait_for(__rel); }
00504
00505 template<typename _Clock, typename _Duration>
00506 bool
00507 wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const
00508 { return _M_state->wait_until(__abs); }
00509
00510 protected:
00511
00512 __result_type
00513 _M_get_result()
00514 {
00515 _Result_base& __res = _M_state->wait();
00516 if (!(__res._M_error == 0))
00517 rethrow_exception(__res._M_error);
00518 return static_cast<__result_type>(__res);
00519 }
00520
00521 void _M_swap(__basic_future& __that)
00522 {
00523 _M_state.swap(__that._M_state);
00524 }
00525
00526
00527 explicit
00528 __basic_future(const __state_type& __state) : _M_state(__state)
00529 {
00530 _State::_S_check(_M_state);
00531 _M_state->_M_set_retrieved_flag();
00532 }
00533
00534
00535 explicit
00536 __basic_future(const shared_future<_Res>&);
00537
00538
00539 explicit
00540 __basic_future(shared_future<_Res>&&);
00541
00542
00543 explicit
00544 __basic_future(future<_Res>&&);
00545
00546 __basic_future() { }
00547
00548 struct _Reset
00549 {
00550 explicit _Reset(__basic_future& __fut) : _M_fut(__fut) { }
00551 ~_Reset() { _M_fut._M_state.reset(); }
00552 __basic_future& _M_fut;
00553 };
00554 };
00555
00556
00557
00558 template<typename _Res>
00559 class future : public __basic_future<_Res>
00560 {
00561 friend class promise<_Res>;
00562 template<typename> friend class packaged_task;
00563 template<typename _Fn, typename... _Args>
00564 friend future<typename result_of<_Fn(_Args...)>::type>
00565 async(launch, _Fn&&, _Args&&...);
00566
00567 typedef __basic_future<_Res> _Base_type;
00568 typedef typename _Base_type::__state_type __state_type;
00569
00570 explicit
00571 future(const __state_type& __state) : _Base_type(__state) { }
00572
00573 public:
00574 future() : _Base_type() { }
00575
00576
00577 future(future&& __uf) : _Base_type(std::move(__uf)) { }
00578
00579
00580 future(const future&) = delete;
00581 future& operator=(const future&) = delete;
00582
00583 future& operator=(future&& __fut)
00584 {
00585 future(std::move(__fut))._M_swap(*this);
00586 return *this;
00587 }
00588
00589
00590 _Res
00591 get()
00592 {
00593 typename _Base_type::_Reset __reset(*this);
00594 return std::move(this->_M_get_result()._M_value());
00595 }
00596 };
00597
00598
00599 template<typename _Res>
00600 class future<_Res&> : public __basic_future<_Res&>
00601 {
00602 friend class promise<_Res&>;
00603 template<typename> friend class packaged_task;
00604 template<typename _Fn, typename... _Args>
00605 friend future<typename result_of<_Fn(_Args...)>::type>
00606 async(launch, _Fn&&, _Args&&...);
00607
00608 typedef __basic_future<_Res&> _Base_type;
00609 typedef typename _Base_type::__state_type __state_type;
00610
00611 explicit
00612 future(const __state_type& __state) : _Base_type(__state) { }
00613
00614 public:
00615 future() : _Base_type() { }
00616
00617
00618 future(future&& __uf) : _Base_type(std::move(__uf)) { }
00619
00620
00621 future(const future&) = delete;
00622 future& operator=(const future&) = delete;
00623
00624 future& operator=(future&& __fut)
00625 {
00626 future(std::move(__fut))._M_swap(*this);
00627 return *this;
00628 }
00629
00630
00631 _Res&
00632 get()
00633 {
00634 typename _Base_type::_Reset __reset(*this);
00635 return this->_M_get_result()._M_get();
00636 }
00637 };
00638
00639
00640 template<>
00641 class future<void> : public __basic_future<void>
00642 {
00643 friend class promise<void>;
00644 template<typename> friend class packaged_task;
00645 template<typename _Fn, typename... _Args>
00646 friend future<typename result_of<_Fn(_Args...)>::type>
00647 async(launch, _Fn&&, _Args&&...);
00648
00649 typedef __basic_future<void> _Base_type;
00650 typedef typename _Base_type::__state_type __state_type;
00651
00652 explicit
00653 future(const __state_type& __state) : _Base_type(__state) { }
00654
00655 public:
00656 future() : _Base_type() { }
00657
00658
00659 future(future&& __uf) : _Base_type(std::move(__uf)) { }
00660
00661
00662 future(const future&) = delete;
00663 future& operator=(const future&) = delete;
00664
00665 future& operator=(future&& __fut)
00666 {
00667 future(std::move(__fut))._M_swap(*this);
00668 return *this;
00669 }
00670
00671
00672 void
00673 get()
00674 {
00675 typename _Base_type::_Reset __reset(*this);
00676 this->_M_get_result();
00677 }
00678 };
00679
00680
00681
00682 template<typename _Res>
00683 class shared_future : public __basic_future<_Res>
00684 {
00685 typedef __basic_future<_Res> _Base_type;
00686
00687 public:
00688 shared_future() : _Base_type() { }
00689
00690
00691 shared_future(const shared_future& __sf) : _Base_type(__sf) { }
00692
00693
00694 shared_future(future<_Res>&& __uf)
00695 : _Base_type(std::move(__uf))
00696 { }
00697
00698
00699 shared_future(shared_future&& __sf)
00700 : _Base_type(std::move(__sf))
00701 { }
00702
00703 shared_future& operator=(const shared_future& __sf)
00704 {
00705 shared_future(__sf)._M_swap(*this);
00706 return *this;
00707 }
00708
00709 shared_future& operator=(shared_future&& __sf)
00710 {
00711 shared_future(std::move(__sf))._M_swap(*this);
00712 return *this;
00713 }
00714
00715
00716 const _Res&
00717 get()
00718 {
00719 typename _Base_type::__result_type __r = this->_M_get_result();
00720 _Res& __rs(__r._M_value());
00721 return __rs;
00722 }
00723 };
00724
00725
00726 template<typename _Res>
00727 class shared_future<_Res&> : public __basic_future<_Res&>
00728 {
00729 typedef __basic_future<_Res&> _Base_type;
00730
00731 public:
00732 shared_future() : _Base_type() { }
00733
00734
00735 shared_future(const shared_future& __sf) : _Base_type(__sf) { }
00736
00737
00738 shared_future(future<_Res&>&& __uf)
00739 : _Base_type(std::move(__uf))
00740 { }
00741
00742
00743 shared_future(shared_future&& __sf)
00744 : _Base_type(std::move(__sf))
00745 { }
00746
00747 shared_future& operator=(const shared_future& __sf)
00748 {
00749 shared_future(__sf)._M_swap(*this);
00750 return *this;
00751 }
00752
00753 shared_future& operator=(shared_future&& __sf)
00754 {
00755 shared_future(std::move(__sf))._M_swap(*this);
00756 return *this;
00757 }
00758
00759
00760 _Res&
00761 get() { return this->_M_get_result()._M_get(); }
00762 };
00763
00764
00765 template<>
00766 class shared_future<void> : public __basic_future<void>
00767 {
00768 typedef __basic_future<void> _Base_type;
00769
00770 public:
00771 shared_future() : _Base_type() { }
00772
00773
00774 shared_future(const shared_future& __sf) : _Base_type(__sf) { }
00775
00776
00777 shared_future(future<void>&& __uf)
00778 : _Base_type(std::move(__uf))
00779 { }
00780
00781
00782 shared_future(shared_future&& __sf)
00783 : _Base_type(std::move(__sf))
00784 { }
00785
00786 shared_future& operator=(const shared_future& __sf)
00787 {
00788 shared_future(__sf)._M_swap(*this);
00789 return *this;
00790 }
00791
00792 shared_future& operator=(shared_future&& __sf)
00793 {
00794 shared_future(std::move(__sf))._M_swap(*this);
00795 return *this;
00796 }
00797
00798
00799 void
00800 get() { this->_M_get_result(); }
00801 };
00802
00803
00804 template<typename _Res>
00805 inline __basic_future<_Res>::
00806 __basic_future(const shared_future<_Res>& __sf)
00807 : _M_state(__sf._M_state)
00808 { }
00809
00810 template<typename _Res>
00811 inline __basic_future<_Res>::
00812 __basic_future(shared_future<_Res>&& __sf)
00813 : _M_state(std::move(__sf._M_state))
00814 { }
00815
00816 template<typename _Res>
00817 inline __basic_future<_Res>::
00818 __basic_future(future<_Res>&& __uf)
00819 : _M_state(std::move(__uf._M_state))
00820 { }
00821
00822
00823
00824 template<typename _Res>
00825 class promise
00826 {
00827 typedef __future_base::_State _State;
00828 typedef __future_base::_Result<_Res> _Res_type;
00829 typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
00830 template<typename, typename> friend class _State::_Setter;
00831
00832 shared_ptr<_State> _M_future;
00833 _Ptr_type _M_storage;
00834
00835 public:
00836 promise()
00837 : _M_future(std::make_shared<_State>()),
00838 _M_storage(new _Res_type())
00839 { }
00840
00841 promise(promise&& __rhs)
00842 : _M_future(std::move(__rhs._M_future)),
00843 _M_storage(std::move(__rhs._M_storage))
00844 { }
00845
00846
00847
00848
00849
00850
00851
00852
00853
00854
00855 promise(const promise&) = delete;
00856
00857 ~promise()
00858 {
00859 if (static_cast<bool>(_M_future) && !_M_future.unique())
00860 _M_future->_M_break_promise(std::move(_M_storage));
00861 }
00862
00863
00864 promise&
00865 operator=(promise&& __rhs)
00866 {
00867 promise(std::move(__rhs)).swap(*this);
00868 return *this;
00869 }
00870
00871 promise& operator=(const promise&) = delete;
00872
00873 void
00874 swap(promise& __rhs)
00875 {
00876 _M_future.swap(__rhs._M_future);
00877 _M_storage.swap(__rhs._M_storage);
00878 }
00879
00880
00881 future<_Res>
00882 get_future()
00883 { return future<_Res>(_M_future); }
00884
00885
00886 void
00887 set_value(const _Res& __r)
00888 {
00889 auto __setter = _State::__setter(this, __r);
00890 _M_future->_M_set_result(std::move(__setter));
00891 }
00892
00893 void
00894 set_value(_Res&& __r)
00895 {
00896 auto __setter = _State::__setter(this, std::move(__r));
00897 _M_future->_M_set_result(std::move(__setter));
00898 }
00899
00900 void
00901 set_exception(exception_ptr __p)
00902 {
00903 auto __setter = _State::__setter(__p, this);
00904 _M_future->_M_set_result(std::move(__setter));
00905 }
00906 };
00907
00908 template<typename _Res>
00909 inline void
00910 swap(promise<_Res>& __x, promise<_Res>& __y)
00911 { __x.swap(__y); }
00912
00913
00914 template<typename _Res>
00915 class promise<_Res&>
00916 {
00917 typedef __future_base::_State _State;
00918 typedef __future_base::_Result<_Res&> _Res_type;
00919 typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
00920 template<typename, typename> friend class _State::_Setter;
00921
00922 shared_ptr<_State> _M_future;
00923 _Ptr_type _M_storage;
00924
00925 public:
00926 promise()
00927 : _M_future(std::make_shared<_State>()),
00928 _M_storage(new _Res_type())
00929 { }
00930
00931 promise(promise&& __rhs)
00932 : _M_future(std::move(__rhs._M_future)),
00933 _M_storage(std::move(__rhs._M_storage))
00934 { }
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945 promise(const promise&) = delete;
00946
00947 ~promise()
00948 {
00949 if (static_cast<bool>(_M_future) && !_M_future.unique())
00950 _M_future->_M_break_promise(std::move(_M_storage));
00951 }
00952
00953
00954 promise&
00955 operator=(promise&& __rhs)
00956 {
00957 promise(std::move(__rhs)).swap(*this);
00958 return *this;
00959 }
00960
00961 promise& operator=(const promise&) = delete;
00962
00963 void
00964 swap(promise& __rhs)
00965 {
00966 _M_future.swap(__rhs._M_future);
00967 _M_storage.swap(__rhs._M_storage);
00968 }
00969
00970
00971 future<_Res&>
00972 get_future()
00973 { return future<_Res&>(_M_future); }
00974
00975
00976 void
00977 set_value(_Res& __r)
00978 {
00979 auto __setter = _State::__setter(this, __r);
00980 _M_future->_M_set_result(std::move(__setter));
00981 }
00982
00983 void
00984 set_exception(exception_ptr __p)
00985 {
00986 auto __setter = _State::__setter(__p, this);
00987 _M_future->_M_set_result(std::move(__setter));
00988 }
00989 };
00990
00991
00992 template<>
00993 class promise<void>
00994 {
00995 typedef __future_base::_State _State;
00996 typedef __future_base::_Result<void> _Res_type;
00997 typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
00998 template<typename, typename> friend class _State::_Setter;
00999
01000 shared_ptr<_State> _M_future;
01001 _Ptr_type _M_storage;
01002
01003 public:
01004 promise()
01005 : _M_future(std::make_shared<_State>()),
01006 _M_storage(new _Res_type())
01007 { }
01008
01009 promise(promise&& __rhs)
01010 : _M_future(std::move(__rhs._M_future)),
01011 _M_storage(std::move(__rhs._M_storage))
01012 { }
01013
01014
01015
01016
01017
01018
01019
01020
01021
01022
01023
01024 promise(const promise&) = delete;
01025
01026 ~promise()
01027 {
01028 if (static_cast<bool>(_M_future) && !_M_future.unique())
01029 _M_future->_M_break_promise(std::move(_M_storage));
01030 }
01031
01032
01033 promise&
01034 operator=(promise&& __rhs)
01035 {
01036 promise(std::move(__rhs)).swap(*this);
01037 return *this;
01038 }
01039
01040 promise& operator=(const promise&) = delete;
01041
01042 void
01043 swap(promise& __rhs)
01044 {
01045 _M_future.swap(__rhs._M_future);
01046 _M_storage.swap(__rhs._M_storage);
01047 }
01048
01049
01050 future<void>
01051 get_future()
01052 { return future<void>(_M_future); }
01053
01054
01055 void set_value();
01056
01057 void
01058 set_exception(exception_ptr __p)
01059 {
01060 auto __setter = _State::__setter(__p, this);
01061 _M_future->_M_set_result(std::move(__setter));
01062 }
01063 };
01064
01065
01066 template<>
01067 struct __future_base::_State::_Setter<void, void>
01068 {
01069 promise<void>::_Ptr_type operator()()
01070 {
01071 _State::_S_check(_M_promise->_M_future);
01072 return std::move(_M_promise->_M_storage);
01073 }
01074
01075 promise<void>* _M_promise;
01076 };
01077
01078 inline __future_base::_State::_Setter<void, void>
01079 __future_base::_State::__setter(promise<void>* __prom)
01080 {
01081 return _Setter<void, void>{ __prom };
01082 }
01083
01084 inline void
01085 promise<void>::set_value()
01086 {
01087 auto __setter = _State::__setter(this);
01088 _M_future->_M_set_result(std::move(__setter));
01089 }
01090
01091
01092
01093
01094
01095
01096
01097
01098 template<typename _StateT, typename _Res>
01099 struct __future_base::_Task_setter
01100 {
01101 typename _StateT::_Ptr_type operator()()
01102 {
01103 __try
01104 {
01105 _M_state->_M_result->_M_set(_M_fn());
01106 }
01107 __catch(...)
01108 {
01109 _M_state->_M_result->_M_error = current_exception();
01110 }
01111 return std::move(_M_state->_M_result);
01112 }
01113 _StateT* _M_state;
01114 std::function<_Res()> _M_fn;
01115 };
01116
01117 template<typename _StateT>
01118 struct __future_base::_Task_setter<_StateT, void>
01119 {
01120 typename _StateT::_Ptr_type operator()()
01121 {
01122 __try
01123 {
01124 _M_fn();
01125 }
01126 __catch(...)
01127 {
01128 _M_state->_M_result->_M_error = current_exception();
01129 }
01130 return std::move(_M_state->_M_result);
01131 }
01132 _StateT* _M_state;
01133 std::function<void()> _M_fn;
01134 };
01135
01136 template<typename _Res, typename... _Args>
01137 struct __future_base::_Task_state<_Res(_Args...)> : __future_base::_State
01138 {
01139 typedef _Res _Res_type;
01140
01141 _Task_state(std::function<_Res(_Args...)> __task)
01142 : _M_result(new _Result<_Res>()), _M_task(std::move(__task))
01143 { }
01144
01145
01146
01147
01148
01149
01150
01151
01152
01153
01154 void
01155 _M_run(_Args... __args)
01156 {
01157
01158 auto __bound = std::bind<_Res>(_M_task,
01159 _S_maybe_wrap_ref(std::forward<_Args>(__args))...);
01160 _Task_setter<_Task_state> __setter{ this, std::move(__bound) };
01161 _M_set_result(std::move(__setter));
01162 }
01163
01164 template<typename, typename> friend class _Task_setter;
01165 typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type;
01166 _Ptr_type _M_result;
01167 std::function<_Res(_Args...)> _M_task;
01168
01169 template<typename _Tp>
01170 static reference_wrapper<_Tp>
01171 _S_maybe_wrap_ref(_Tp& __t)
01172 { return std::ref(__t); }
01173
01174 template<typename _Tp>
01175 static typename enable_if<!is_lvalue_reference<_Tp>::value,
01176 _Tp>::type&&
01177 _S_maybe_wrap_ref(_Tp&& __t)
01178 { return std::forward<_Tp>(__t); }
01179 };
01180
01181
01182 template<typename _Res, typename... _ArgTypes>
01183 class packaged_task<_Res(_ArgTypes...)>
01184 {
01185 typedef __future_base::_Task_state<_Res(_ArgTypes...)> _State_type;
01186 shared_ptr<_State_type> _M_state;
01187
01188 public:
01189 typedef _Res result_type;
01190
01191
01192 packaged_task() { }
01193
01194 template<typename _Fn>
01195 explicit
01196 packaged_task(const _Fn& __fn)
01197 : _M_state(std::make_shared<_State_type>(__fn))
01198 { }
01199
01200 template<typename _Fn>
01201 explicit
01202 packaged_task(_Fn&& __fn)
01203 : _M_state(std::make_shared<_State_type>(std::move(__fn)))
01204 { }
01205
01206 explicit
01207 packaged_task(_Res(*__fn)(_ArgTypes...))
01208 : _M_state(std::make_shared<_State_type>(__fn))
01209 { }
01210
01211
01212
01213
01214
01215
01216
01217
01218
01219
01220 ~packaged_task()
01221 {
01222 if (static_cast<bool>(_M_state) && !_M_state.unique())
01223 _M_state->_M_break_promise(std::move(_M_state->_M_result));
01224 }
01225
01226
01227 packaged_task(packaged_task&) = delete;
01228 packaged_task& operator=(packaged_task&) = delete;
01229
01230
01231 packaged_task(packaged_task&& __other)
01232 { this->swap(__other); }
01233
01234 packaged_task& operator=(packaged_task&& __other)
01235 {
01236 packaged_task(std::move(__other)).swap(*this);
01237 return *this;
01238 }
01239
01240 void
01241 swap(packaged_task& __other)
01242 { _M_state.swap(__other._M_state); }
01243
01244 explicit operator bool() const { return static_cast<bool>(_M_state); }
01245
01246
01247 future<_Res>
01248 get_future()
01249 { return future<_Res>(_M_state); }
01250
01251
01252 void
01253 operator()(_ArgTypes... __args)
01254 {
01255 __future_base::_State::_S_check(_M_state);
01256 _M_state->_M_run(std::forward<_ArgTypes>(__args)...);
01257 }
01258
01259 void
01260 reset()
01261 {
01262 __future_base::_State::_S_check(_M_state);
01263 packaged_task(std::move(_M_state->_M_task)).swap(*this);
01264 }
01265 };
01266
01267 template<typename _Res, typename... _ArgTypes>
01268 inline void
01269 swap(packaged_task<_Res(_ArgTypes...)>& __x,
01270 packaged_task<_Res(_ArgTypes...)>& __y)
01271 { __x.swap(__y); }
01272
01273 template<typename _Res>
01274 class __future_base::_Deferred_state : public __future_base::_State
01275 {
01276 public:
01277 typedef _Res _Res_type;
01278
01279 explicit
01280 _Deferred_state(std::function<_Res()>&& __fn)
01281 : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
01282 { }
01283
01284 private:
01285 template<typename, typename> friend class _Task_setter;
01286 typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type;
01287 _Ptr_type _M_result;
01288 std::function<_Res()> _M_fn;
01289
01290 virtual void
01291 _M_run_deferred()
01292 {
01293 _Task_setter<_Deferred_state> __setter{ this, _M_fn };
01294
01295 _M_set_result(std::move(__setter), true);
01296 }
01297 };
01298
01299 template<typename _Res>
01300 class __future_base::_Async_state : public __future_base::_State
01301 {
01302 public:
01303 typedef _Res _Res_type;
01304
01305 explicit
01306 _Async_state(std::function<_Res()>&& __fn)
01307 : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)),
01308 _M_thread(mem_fn(&_Async_state::_M_do_run), this)
01309 { }
01310
01311 ~_Async_state() { _M_thread.join(); }
01312
01313 private:
01314 void _M_do_run()
01315 {
01316 _Task_setter<_Async_state> __setter{ this, std::move(_M_fn) };
01317 _M_set_result(std::move(__setter));
01318 }
01319
01320 template<typename, typename> friend class _Task_setter;
01321 typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type;
01322 _Ptr_type _M_result;
01323 std::function<_Res()> _M_fn;
01324 thread _M_thread;
01325 };
01326
01327 template<typename _Fn, typename... _Args>
01328 future<typename result_of<_Fn(_Args...)>::type>
01329 async(launch __policy, _Fn&& __fn, _Args&&... __args)
01330 {
01331 typedef typename result_of<_Fn(_Args...)>::type result_type;
01332 std::shared_ptr<__future_base::_State> __state;
01333 if (__policy == launch::async)
01334 {
01335 typedef typename __future_base::_Async_state<result_type> _State;
01336 __state = std::make_shared<_State>(std::bind<result_type>(
01337 std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
01338 }
01339 else
01340 {
01341 typedef typename __future_base::_Deferred_state<result_type> _State;
01342 __state = std::make_shared<_State>(std::bind<result_type>(
01343 std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
01344 }
01345 return future<result_type>(__state);
01346 }
01347
01348 template<typename _Fn, typename... _Args>
01349 inline typename
01350 enable_if<!is_same<typename decay<_Fn>::type, launch>::value,
01351 future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
01352 >::type
01353 async(_Fn&& __fn, _Args&&... __args)
01354 {
01355 return async(launch::any, std::forward<_Fn>(__fn),
01356 std::forward<_Args>(__args)...);
01357 }
01358
01359 #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
01360
01361
01362
01363 }
01364
01365 #endif // __GXX_EXPERIMENTAL_CXX0X__
01366
01367 #endif // _GLIBCXX_FUTURE