1 // <future> -*- C++ -*-
3 // Copyright (C) 2009, 2010 Free Software Foundation, Inc.
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
26 * This is a Standard C++ Library header.
29 #ifndef _GLIBCXX_FUTURE
30 #define _GLIBCXX_FUTURE 1
32 #pragma GCC system_header
34 #ifndef __GXX_EXPERIMENTAL_CXX0X__
35 # include <bits/c++0x_warning.h>
42 #include <condition_variable>
43 #include <system_error>
46 #include <bits/functexcept.h>
51 * @defgroup futures Futures
52 * @ingroup concurrency
54 * Classes for futures support.
58 /// Error code for futures
59 enum class future_errc
62 future_already_retrieved,
63 promise_already_satisfied,
68 struct is_error_code_enum<future_errc> : public true_type { };
70 /// Points to a statically-allocated object derived from error_category.
71 extern const error_category* const future_category;
73 // TODO: requires constexpr
74 inline error_code make_error_code(future_errc __errc)
75 { return error_code(static_cast<int>(__errc), *future_category); }
77 // TODO: requires constexpr
78 inline error_condition make_error_condition(future_errc __errc)
79 { return error_condition(static_cast<int>(__errc), *future_category); }
82 * @brief Exception type thrown by futures.
85 class future_error : public logic_error
90 explicit future_error(error_code __ec)
91 : logic_error("std::future_error"), _M_code(__ec)
94 virtual ~future_error() throw();
100 code() const throw() { return _M_code; }
103 // Forward declarations.
104 template<typename _Res>
107 template<typename _Res>
110 template<typename _Res>
113 template<typename _Signature>
116 template<typename _Res>
119 enum class launch { any, async, sync };
121 template<typename _Fn, typename... _Args>
122 future<typename result_of<_Fn(_Args...)>::type>
123 async(launch __policy, _Fn&& __fn, _Args&&... __args);
125 template<typename _Fn, typename... _Args>
127 enable_if<!is_same<typename decay<_Fn>::type, launch>::value,
128 future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
130 async(_Fn&& __fn, _Args&&... __args);
132 #if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1) \
133 && defined(_GLIBCXX_ATOMIC_BUILTINS_4)
135 /// Base class and enclosing scope.
138 /// Base class for results.
141 exception_ptr _M_error;
143 _Result_base() = default;
144 _Result_base(const _Result_base&) = delete;
145 _Result_base& operator=(const _Result_base&) = delete;
147 // _M_destroy() allows derived classes to control deallocation
148 virtual void _M_destroy() = 0;
152 void operator()(_Result_base* __fr) const { __fr->_M_destroy(); }
160 template<typename _Res>
161 struct _Result : _Result_base
164 typedef alignment_of<_Res> __a_of;
165 typedef aligned_storage<sizeof(_Res), __a_of::value> __align_storage;
166 typedef typename __align_storage::type __align_type;
168 __align_type _M_storage;
172 _Result() : _M_initialized() { }
180 // Return lvalue, future will add const or rvalue-reference
182 _M_value() { return *static_cast<_Res*>(_M_addr()); }
185 _M_set(const _Res& __res)
187 ::new (_M_addr()) _Res(__res);
188 _M_initialized = true;
194 ::new (_M_addr()) _Res(std::move(__res));
195 _M_initialized = true;
199 void _M_destroy() { delete this; }
201 void* _M_addr() { return static_cast<void*>(&_M_storage); }
204 // TODO: use template alias when available
206 template<typename _Res>
207 using _Ptr = unique_ptr<_Res, _Result_base::_Deleter>;
209 /// A unique_ptr based on the instantiating type.
210 template<typename _Res>
213 typedef unique_ptr<_Res, _Result_base::_Deleter> type;
216 // TODO: use when allocator_arg_t available
219 template<typename _Res, typename _Alloc>
220 struct _Result_alloc : _Result<_Res>
222 typedef typename _Alloc::template rebind<_Result_alloc>::other
226 _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _M_alloc(__a)
232 __allocator_type __a(_M_alloc);
234 __a.deallocate(this, 1);
237 __allocator_type _M_alloc;
240 template<typename _Res, typename _Allocator>
241 static typename _Ptr<_Result_alloc<_Res, _Allocator>>::type
242 _S_allocate_result(const _Allocator& __a)
244 typedef _Result_alloc<_Res, _Allocator> __result_type;
245 typename __result_type::__allocator_type __a2(__a);
246 __result_type* __p = __a2.allocate(1);
249 __a2.construct(__p, __a);
253 __a2.deallocate(__p, 1);
254 __throw_exception_again;
256 return typename _Ptr<__result_type>::type(__p);
261 /// Shared state between a promise and one or more associated futures.
264 typedef _Ptr<_Result_base>::type _Ptr_type;
268 condition_variable _M_cond;
269 atomic_flag _M_retrieved;
273 _State() : _M_result(), _M_retrieved(ATOMIC_FLAG_INIT) { }
275 _State(const _State&) = delete;
276 _State& operator=(const _State&) = delete;
282 unique_lock<mutex> __lock(_M_mutex);
284 _M_cond.wait(__lock, std::bind<bool>(&_State::_M_ready, this));
288 template<typename _Rep, typename _Period>
290 wait_for(const chrono::duration<_Rep, _Period>& __rel)
292 unique_lock<mutex> __lock(_M_mutex);
293 auto __bound = std::bind<bool>(&_State::_M_ready, this);
294 return _M_ready() || _M_cond.wait_for(__lock, __rel, __bound);
297 template<typename _Clock, typename _Duration>
299 wait_until(const chrono::time_point<_Clock, _Duration>& __abs)
301 unique_lock<mutex> __lock(_M_mutex);
302 auto __bound = std::bind<bool>(&_State::_M_ready, this);
303 return _M_ready() || _M_cond.wait_until(__lock, __abs, __bound);
307 _M_set_result(function<_Ptr_type()> __res, bool __ignore_failure = false)
309 bool __set = __ignore_failure;
310 // all calls to this function are serialized,
311 // side-effects of invoking __res only happen once
312 call_once(_M_once, &_State::_M_do_set, this, ref(__res),
315 __throw_future_error(int(future_errc::promise_already_satisfied));
319 _M_break_promise(_Ptr_type __res)
321 if (static_cast<bool>(__res))
323 error_code __ec(make_error_code(future_errc::broken_promise));
324 __res->_M_error = copy_exception(future_error(__ec));
326 lock_guard<mutex> __lock(_M_mutex);
327 _M_result.swap(__res);
329 _M_cond.notify_all();
333 // Called when this object is passed to a future.
335 _M_set_retrieved_flag()
337 if (_M_retrieved.test_and_set())
338 __throw_future_error(int(future_errc::future_already_retrieved));
341 template<typename _Res, typename _Arg>
345 template<typename _Res, typename _Arg>
346 struct _Setter<_Res, _Arg&>
348 // check this is only used by promise<R>::set_value(const R&)
349 // or promise<R>::set_value(R&)
350 static_assert(is_same<_Res, _Arg&>::value // promise<R&>
351 || is_same<const _Res, _Arg>::value, // promise<R>
352 "Invalid specialisation");
354 typename promise<_Res>::_Ptr_type operator()()
356 _State::_S_check(_M_promise->_M_future);
357 _M_promise->_M_storage->_M_set(_M_arg);
358 return std::move(_M_promise->_M_storage);
360 promise<_Res>* _M_promise;
365 template<typename _Res>
366 struct _Setter<_Res, _Res&&>
368 typename promise<_Res>::_Ptr_type operator()()
370 _State::_S_check(_M_promise->_M_future);
371 _M_promise->_M_storage->_M_set(std::move(_M_arg));
372 return std::move(_M_promise->_M_storage);
374 promise<_Res>* _M_promise;
378 struct __exception_ptr_tag { };
381 template<typename _Res>
382 struct _Setter<_Res, __exception_ptr_tag>
384 typename promise<_Res>::_Ptr_type operator()()
386 _State::_S_check(_M_promise->_M_future);
387 _M_promise->_M_storage->_M_error = _M_ex;
388 return std::move(_M_promise->_M_storage);
391 promise<_Res>* _M_promise;
392 exception_ptr& _M_ex;
395 template<typename _Res, typename _Arg>
396 static _Setter<_Res, _Arg&&>
397 __setter(promise<_Res>* __prom, _Arg&& __arg)
399 return _Setter<_Res, _Arg&&>{ __prom, __arg };
402 template<typename _Res>
403 static _Setter<_Res, __exception_ptr_tag>
404 __setter(exception_ptr& __ex, promise<_Res>* __prom)
406 return _Setter<_Res, __exception_ptr_tag>{ __prom, __ex };
409 static _Setter<void, void>
410 __setter(promise<void>* __prom);
412 template<typename _Tp>
414 _S_check(const shared_ptr<_Tp>& __p)
416 if (!static_cast<bool>(__p))
417 __throw_future_error((int)future_errc::no_state);
422 _M_do_set(function<_Ptr_type()>& __f, bool& __set)
424 _Ptr_type __res = __f();
426 lock_guard<mutex> __lock(_M_mutex);
427 _M_result.swap(__res);
429 _M_cond.notify_all();
433 bool _M_ready() const { return static_cast<bool>(_M_result); }
435 virtual void _M_run_deferred() { }
438 template<typename _Res>
439 class _Deferred_state;
441 template<typename _Res>
444 template<typename _Signature>
447 template<typename _StateT, typename _Res = typename _StateT::_Res_type>
451 inline __future_base::_Result_base::~_Result_base() = default;
453 /// Partial specialization for reference types.
454 template<typename _Res>
455 struct __future_base::_Result<_Res&> : __future_base::_Result_base
457 _Result() : _M_value_ptr() { }
459 void _M_set(_Res& __res) { _M_value_ptr = &__res; }
461 _Res& _M_get() { return *_M_value_ptr; }
466 void _M_destroy() { delete this; }
469 /// Explicit specialization for void.
471 struct __future_base::_Result<void> : __future_base::_Result_base
474 void _M_destroy() { delete this; }
478 /// Common implementation for future and shared_future.
479 template<typename _Res>
480 class __basic_future : public __future_base
483 typedef shared_ptr<_State> __state_type;
484 typedef __future_base::_Result<_Res>& __result_type;
487 __state_type _M_state;
491 __basic_future(const __basic_future&) = delete;
492 __basic_future& operator=(const __basic_future&) = delete;
495 valid() const { return static_cast<bool>(_M_state); }
498 wait() const { _M_state->wait(); }
500 template<typename _Rep, typename _Period>
502 wait_for(const chrono::duration<_Rep, _Period>& __rel) const
503 { return _M_state->wait_for(__rel); }
505 template<typename _Clock, typename _Duration>
507 wait_until(const chrono::time_point<_Clock, _Duration>& __abs) const
508 { return _M_state->wait_until(__abs); }
511 /// Wait for the state to be ready and rethrow any stored exception
515 _Result_base& __res = _M_state->wait();
516 if (!(__res._M_error == 0))
517 rethrow_exception(__res._M_error);
518 return static_cast<__result_type>(__res);
521 void _M_swap(__basic_future& __that)
523 _M_state.swap(__that._M_state);
526 // Construction of a future by promise::get_future()
528 __basic_future(const __state_type& __state) : _M_state(__state)
530 _State::_S_check(_M_state);
531 _M_state->_M_set_retrieved_flag();
534 // Copy construction from a shared_future
536 __basic_future(const shared_future<_Res>&);
538 // Move construction from a shared_future
540 __basic_future(shared_future<_Res>&&);
542 // Move construction from a future
544 __basic_future(future<_Res>&&);
550 explicit _Reset(__basic_future& __fut) : _M_fut(__fut) { }
551 ~_Reset() { _M_fut._M_state.reset(); }
552 __basic_future& _M_fut;
557 /// Primary template for future.
558 template<typename _Res>
559 class future : public __basic_future<_Res>
561 friend class promise<_Res>;
562 template<typename> friend class packaged_task;
563 template<typename _Fn, typename... _Args>
564 friend future<typename result_of<_Fn(_Args...)>::type>
565 async(launch, _Fn&&, _Args&&...);
567 typedef __basic_future<_Res> _Base_type;
568 typedef typename _Base_type::__state_type __state_type;
571 future(const __state_type& __state) : _Base_type(__state) { }
574 future() : _Base_type() { }
577 future(future&& __uf) : _Base_type(std::move(__uf)) { }
580 future(const future&) = delete;
581 future& operator=(const future&) = delete;
583 future& operator=(future&& __fut)
585 future(std::move(__fut))._M_swap(*this);
589 /// Retrieving the value
593 typename _Base_type::_Reset __reset(*this);
594 return std::move(this->_M_get_result()._M_value());
598 /// Partial specialization for future<R&>
599 template<typename _Res>
600 class future<_Res&> : public __basic_future<_Res&>
602 friend class promise<_Res&>;
603 template<typename> friend class packaged_task;
604 template<typename _Fn, typename... _Args>
605 friend future<typename result_of<_Fn(_Args...)>::type>
606 async(launch, _Fn&&, _Args&&...);
608 typedef __basic_future<_Res&> _Base_type;
609 typedef typename _Base_type::__state_type __state_type;
612 future(const __state_type& __state) : _Base_type(__state) { }
615 future() : _Base_type() { }
618 future(future&& __uf) : _Base_type(std::move(__uf)) { }
621 future(const future&) = delete;
622 future& operator=(const future&) = delete;
624 future& operator=(future&& __fut)
626 future(std::move(__fut))._M_swap(*this);
630 /// Retrieving the value
634 typename _Base_type::_Reset __reset(*this);
635 return this->_M_get_result()._M_get();
639 /// Explicit specialization for future<void>
641 class future<void> : public __basic_future<void>
643 friend class promise<void>;
644 template<typename> friend class packaged_task;
645 template<typename _Fn, typename... _Args>
646 friend future<typename result_of<_Fn(_Args...)>::type>
647 async(launch, _Fn&&, _Args&&...);
649 typedef __basic_future<void> _Base_type;
650 typedef typename _Base_type::__state_type __state_type;
653 future(const __state_type& __state) : _Base_type(__state) { }
656 future() : _Base_type() { }
659 future(future&& __uf) : _Base_type(std::move(__uf)) { }
662 future(const future&) = delete;
663 future& operator=(const future&) = delete;
665 future& operator=(future&& __fut)
667 future(std::move(__fut))._M_swap(*this);
671 /// Retrieving the value
675 typename _Base_type::_Reset __reset(*this);
676 this->_M_get_result();
681 /// Primary template for shared_future.
682 template<typename _Res>
683 class shared_future : public __basic_future<_Res>
685 typedef __basic_future<_Res> _Base_type;
688 shared_future() : _Base_type() { }
691 shared_future(const shared_future& __sf) : _Base_type(__sf) { }
693 /// Construct from a future rvalue
694 shared_future(future<_Res>&& __uf)
695 : _Base_type(std::move(__uf))
698 /// Construct from a shared_future rvalue
699 shared_future(shared_future&& __sf)
700 : _Base_type(std::move(__sf))
703 shared_future& operator=(const shared_future& __sf)
705 shared_future(__sf)._M_swap(*this);
709 shared_future& operator=(shared_future&& __sf)
711 shared_future(std::move(__sf))._M_swap(*this);
715 /// Retrieving the value
719 typename _Base_type::__result_type __r = this->_M_get_result();
720 _Res& __rs(__r._M_value());
725 /// Partial specialization for shared_future<R&>
726 template<typename _Res>
727 class shared_future<_Res&> : public __basic_future<_Res&>
729 typedef __basic_future<_Res&> _Base_type;
732 shared_future() : _Base_type() { }
735 shared_future(const shared_future& __sf) : _Base_type(__sf) { }
737 /// Construct from a future rvalue
738 shared_future(future<_Res&>&& __uf)
739 : _Base_type(std::move(__uf))
742 /// Construct from a shared_future rvalue
743 shared_future(shared_future&& __sf)
744 : _Base_type(std::move(__sf))
747 shared_future& operator=(const shared_future& __sf)
749 shared_future(__sf)._M_swap(*this);
753 shared_future& operator=(shared_future&& __sf)
755 shared_future(std::move(__sf))._M_swap(*this);
759 /// Retrieving the value
761 get() { return this->_M_get_result()._M_get(); }
764 /// Explicit specialization for shared_future<void>
766 class shared_future<void> : public __basic_future<void>
768 typedef __basic_future<void> _Base_type;
771 shared_future() : _Base_type() { }
774 shared_future(const shared_future& __sf) : _Base_type(__sf) { }
776 /// Construct from a future rvalue
777 shared_future(future<void>&& __uf)
778 : _Base_type(std::move(__uf))
781 /// Construct from a shared_future rvalue
782 shared_future(shared_future&& __sf)
783 : _Base_type(std::move(__sf))
786 shared_future& operator=(const shared_future& __sf)
788 shared_future(__sf)._M_swap(*this);
792 shared_future& operator=(shared_future&& __sf)
794 shared_future(std::move(__sf))._M_swap(*this);
798 // Retrieving the value
800 get() { this->_M_get_result(); }
803 // Now we can define the protected __basic_future constructors.
804 template<typename _Res>
805 inline __basic_future<_Res>::
806 __basic_future(const shared_future<_Res>& __sf)
807 : _M_state(__sf._M_state)
810 template<typename _Res>
811 inline __basic_future<_Res>::
812 __basic_future(shared_future<_Res>&& __sf)
813 : _M_state(std::move(__sf._M_state))
816 template<typename _Res>
817 inline __basic_future<_Res>::
818 __basic_future(future<_Res>&& __uf)
819 : _M_state(std::move(__uf._M_state))
823 /// Primary template for promise
824 template<typename _Res>
827 typedef __future_base::_State _State;
828 typedef __future_base::_Result<_Res> _Res_type;
829 typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
830 template<typename, typename> friend class _State::_Setter;
832 shared_ptr<_State> _M_future;
833 _Ptr_type _M_storage;
837 : _M_future(std::make_shared<_State>()),
838 _M_storage(new _Res_type())
841 promise(promise&& __rhs)
842 : _M_future(std::move(__rhs._M_future)),
843 _M_storage(std::move(__rhs._M_storage))
846 // TODO: needs allocator_arg_t
848 template<typename _Allocator>
849 promise(allocator_arg_t, const _Allocator& __a)
850 : _M_future(std::allocate_shared<_State>(__a)),
851 _M_storage(__future_base::_S_allocate_result<_Res>(__a))
855 promise(const promise&) = delete;
859 if (static_cast<bool>(_M_future) && !_M_future.unique())
860 _M_future->_M_break_promise(std::move(_M_storage));
865 operator=(promise&& __rhs)
867 promise(std::move(__rhs)).swap(*this);
871 promise& operator=(const promise&) = delete;
876 _M_future.swap(__rhs._M_future);
877 _M_storage.swap(__rhs._M_storage);
880 // Retrieving the result
883 { return future<_Res>(_M_future); }
885 // Setting the result
887 set_value(const _Res& __r)
889 auto __setter = _State::__setter(this, __r);
890 _M_future->_M_set_result(std::move(__setter));
894 set_value(_Res&& __r)
896 auto __setter = _State::__setter(this, std::move(__r));
897 _M_future->_M_set_result(std::move(__setter));
901 set_exception(exception_ptr __p)
903 auto __setter = _State::__setter(__p, this);
904 _M_future->_M_set_result(std::move(__setter));
908 template<typename _Res>
910 swap(promise<_Res>& __x, promise<_Res>& __y)
913 /// Partial specialization for promise<R&>
914 template<typename _Res>
917 typedef __future_base::_State _State;
918 typedef __future_base::_Result<_Res&> _Res_type;
919 typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
920 template<typename, typename> friend class _State::_Setter;
922 shared_ptr<_State> _M_future;
923 _Ptr_type _M_storage;
927 : _M_future(std::make_shared<_State>()),
928 _M_storage(new _Res_type())
931 promise(promise&& __rhs)
932 : _M_future(std::move(__rhs._M_future)),
933 _M_storage(std::move(__rhs._M_storage))
936 // TODO: needs allocator_arg_t
938 template<typename _Allocator>
939 promise(allocator_arg_t, const _Allocator& __a)
940 : _M_future(std::allocate_shared<_State>(__a)),
941 _M_storage(__future_base::_S_allocate_result<_Res&>(__a))
945 promise(const promise&) = delete;
949 if (static_cast<bool>(_M_future) && !_M_future.unique())
950 _M_future->_M_break_promise(std::move(_M_storage));
955 operator=(promise&& __rhs)
957 promise(std::move(__rhs)).swap(*this);
961 promise& operator=(const promise&) = delete;
966 _M_future.swap(__rhs._M_future);
967 _M_storage.swap(__rhs._M_storage);
970 // Retrieving the result
973 { return future<_Res&>(_M_future); }
975 // Setting the result
979 auto __setter = _State::__setter(this, __r);
980 _M_future->_M_set_result(std::move(__setter));
984 set_exception(exception_ptr __p)
986 auto __setter = _State::__setter(__p, this);
987 _M_future->_M_set_result(std::move(__setter));
991 /// Explicit specialization for promise<void>
995 typedef __future_base::_State _State;
996 typedef __future_base::_Result<void> _Res_type;
997 typedef typename __future_base::_Ptr<_Res_type>::type _Ptr_type;
998 template<typename, typename> friend class _State::_Setter;
1000 shared_ptr<_State> _M_future;
1001 _Ptr_type _M_storage;
1005 : _M_future(std::make_shared<_State>()),
1006 _M_storage(new _Res_type())
1009 promise(promise&& __rhs)
1010 : _M_future(std::move(__rhs._M_future)),
1011 _M_storage(std::move(__rhs._M_storage))
1015 // TODO: needs allocator_arg_t
1017 template<typename _Allocator>
1018 promise(allocator_arg_t, const _Allocator& __a)
1019 : _M_future(std::allocate_shared<_State>(__a)),
1020 _M_storage(__future_base::_S_allocate_result<void>(__a))
1024 promise(const promise&) = delete;
1028 if (static_cast<bool>(_M_future) && !_M_future.unique())
1029 _M_future->_M_break_promise(std::move(_M_storage));
1034 operator=(promise&& __rhs)
1036 promise(std::move(__rhs)).swap(*this);
1040 promise& operator=(const promise&) = delete;
1043 swap(promise& __rhs)
1045 _M_future.swap(__rhs._M_future);
1046 _M_storage.swap(__rhs._M_storage);
1049 // Retrieving the result
1052 { return future<void>(_M_future); }
1054 // Setting the result
1058 set_exception(exception_ptr __p)
1060 auto __setter = _State::__setter(__p, this);
1061 _M_future->_M_set_result(std::move(__setter));
1067 struct __future_base::_State::_Setter<void, void>
1069 promise<void>::_Ptr_type operator()()
1071 _State::_S_check(_M_promise->_M_future);
1072 return std::move(_M_promise->_M_storage);
1075 promise<void>* _M_promise;
1078 inline __future_base::_State::_Setter<void, void>
1079 __future_base::_State::__setter(promise<void>* __prom)
1081 return _Setter<void, void>{ __prom };
1085 promise<void>::set_value()
1087 auto __setter = _State::__setter(this);
1088 _M_future->_M_set_result(std::move(__setter));
1091 // TODO: needs allocators
1093 template<typename _Res, class Alloc>
1094 struct uses_allocator<promise<_Res>, Alloc> : true_type { };
1098 template<typename _StateT, typename _Res>
1099 struct __future_base::_Task_setter
1101 typename _StateT::_Ptr_type operator()()
1105 _M_state->_M_result->_M_set(_M_fn());
1109 _M_state->_M_result->_M_error = current_exception();
1111 return std::move(_M_state->_M_result);
1114 std::function<_Res()> _M_fn;
1117 template<typename _StateT>
1118 struct __future_base::_Task_setter<_StateT, void>
1120 typename _StateT::_Ptr_type operator()()
1128 _M_state->_M_result->_M_error = current_exception();
1130 return std::move(_M_state->_M_result);
1133 std::function<void()> _M_fn;
1136 template<typename _Res, typename... _Args>
1137 struct __future_base::_Task_state<_Res(_Args...)> : __future_base::_State
1139 typedef _Res _Res_type;
1141 _Task_state(std::function<_Res(_Args...)> __task)
1142 : _M_result(new _Result<_Res>()), _M_task(std::move(__task))
1145 // TODO: needs allocator_arg_t
1147 template<typename _Func, typename _Alloc>
1148 _Task_state(_Func&& __task, const _Alloc& __a)
1149 : _M_result(_S_allocate_result<_Res>(__a))
1150 , _M_task(allocator_arg, __a, std::move(__task))
1155 _M_run(_Args... __args)
1157 // bound arguments decay so wrap lvalue references
1158 auto __bound = std::bind<_Res>(std::ref(_M_task),
1159 _S_maybe_wrap_ref(std::forward<_Args>(__args))...);
1160 _Task_setter<_Task_state> __setter{ this, std::move(__bound) };
1161 _M_set_result(std::move(__setter));
1164 template<typename, typename> friend class _Task_setter;
1165 typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type;
1166 _Ptr_type _M_result;
1167 std::function<_Res(_Args...)> _M_task;
1169 template<typename _Tp>
1170 static reference_wrapper<_Tp>
1171 _S_maybe_wrap_ref(_Tp& __t)
1172 { return std::ref(__t); }
1174 template<typename _Tp>
1175 static typename enable_if<!is_lvalue_reference<_Tp>::value,
1177 _S_maybe_wrap_ref(_Tp&& __t)
1178 { return std::forward<_Tp>(__t); }
1182 template<typename _Res, typename... _ArgTypes>
1183 class packaged_task<_Res(_ArgTypes...)>
1185 typedef __future_base::_Task_state<_Res(_ArgTypes...)> _State_type;
1186 shared_ptr<_State_type> _M_state;
1189 typedef _Res result_type;
1191 // Construction and destruction
1194 template<typename _Fn>
1196 packaged_task(const _Fn& __fn)
1197 : _M_state(std::make_shared<_State_type>(__fn))
1200 template<typename _Fn>
1202 packaged_task(_Fn&& __fn)
1203 : _M_state(std::make_shared<_State_type>(std::move(__fn)))
1207 packaged_task(_Res(*__fn)(_ArgTypes...))
1208 : _M_state(std::make_shared<_State_type>(__fn))
1211 // TODO: needs allocator_arg_t
1213 template<typename _Fn, typename _Allocator>
1215 packaged_task(allocator_arg_t __tag, const _Allocator& __a, _Fn __fn)
1216 : _M_state(std::allocate_shared<_State_type>(__a, std::move(__fn)))
1222 if (static_cast<bool>(_M_state) && !_M_state.unique())
1223 _M_state->_M_break_promise(std::move(_M_state->_M_result));
1227 packaged_task(packaged_task&) = delete;
1228 packaged_task& operator=(packaged_task&) = delete;
1231 packaged_task(packaged_task&& __other)
1232 { this->swap(__other); }
1234 packaged_task& operator=(packaged_task&& __other)
1236 packaged_task(std::move(__other)).swap(*this);
1241 swap(packaged_task& __other)
1242 { _M_state.swap(__other._M_state); }
1244 explicit operator bool() const { return static_cast<bool>(_M_state); }
1249 { return future<_Res>(_M_state); }
1253 operator()(_ArgTypes... __args)
1255 __future_base::_State::_S_check(_M_state);
1256 _M_state->_M_run(std::forward<_ArgTypes>(__args)...);
1262 __future_base::_State::_S_check(_M_state);
1263 packaged_task(std::move(_M_state->_M_task)).swap(*this);
1267 template<typename _Res, typename... _ArgTypes>
1269 swap(packaged_task<_Res(_ArgTypes...)>& __x,
1270 packaged_task<_Res(_ArgTypes...)>& __y)
1273 template<typename _Res>
1274 class __future_base::_Deferred_state : public __future_base::_State
1277 typedef _Res _Res_type;
1280 _Deferred_state(std::function<_Res()>&& __fn)
1281 : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn))
1285 template<typename, typename> friend class _Task_setter;
1286 typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type;
1287 _Ptr_type _M_result;
1288 std::function<_Res()> _M_fn;
1293 _Task_setter<_Deferred_state> __setter{ this, _M_fn };
1294 // safe to call multiple times so ignore failure
1295 _M_set_result(std::move(__setter), true);
1299 template<typename _Res>
1300 class __future_base::_Async_state : public __future_base::_State
1303 typedef _Res _Res_type;
1306 _Async_state(std::function<_Res()>&& __fn)
1307 : _M_result(new _Result<_Res>()), _M_fn(std::move(__fn)),
1308 _M_thread(mem_fn(&_Async_state::_M_do_run), this)
1311 ~_Async_state() { _M_thread.join(); }
1316 _Task_setter<_Async_state> __setter{ this, std::move(_M_fn) };
1317 _M_set_result(std::move(__setter));
1320 template<typename, typename> friend class _Task_setter;
1321 typedef typename __future_base::_Ptr<_Result<_Res>>::type _Ptr_type;
1322 _Ptr_type _M_result;
1323 std::function<_Res()> _M_fn;
1327 template<typename _Fn, typename... _Args>
1328 future<typename result_of<_Fn(_Args...)>::type>
1329 async(launch __policy, _Fn&& __fn, _Args&&... __args)
1331 typedef typename result_of<_Fn(_Args...)>::type result_type;
1332 std::shared_ptr<__future_base::_State> __state;
1333 if (__policy == launch::async)
1335 typedef typename __future_base::_Async_state<result_type> _State;
1336 __state = std::make_shared<_State>(std::bind<result_type>(
1337 std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
1341 typedef typename __future_base::_Deferred_state<result_type> _State;
1342 __state = std::make_shared<_State>(std::bind<result_type>(
1343 std::forward<_Fn>(__fn), std::forward<_Args>(__args)...));
1345 return future<result_type>(__state);
1348 template<typename _Fn, typename... _Args>
1350 enable_if<!is_same<typename decay<_Fn>::type, launch>::value,
1351 future<decltype(std::declval<_Fn>()(std::declval<_Args>()...))>
1353 async(_Fn&& __fn, _Args&&... __args)
1355 return async(launch::any, std::forward<_Fn>(__fn),
1356 std::forward<_Args>(__args)...);
1359 #endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
1360 // && _GLIBCXX_ATOMIC_BUILTINS_4
1365 #endif // __GXX_EXPERIMENTAL_CXX0X__
1367 #endif // _GLIBCXX_FUTURE